mono_domain_get_tls_key ()
{
  pthread_key_t D.20800;

  D.20800 = appdomain_thread_id;
  return D.20800;
}


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

  offset = -1;
  __asm__("	ldr	%0, 1f; b 2f; 1: .word tls_appdomain(tpoff); 2:" : "=r" offset);
  D.20802 = offset;
  return D.20802;
}


mono_jit_info_table_find_internal (struct MonoDomain * domain, char * addr, gboolean try_aot)
{
  long unsigned int D.20804;
  long unsigned int D.20805;
  struct MonoJitInfoTable * volatile * D.20806;
  struct MonoJitInfo * D.20813;
  struct MonoDomain * mono_root_domain.0;
  struct MonoJitInfoTable * D.20819;
  struct MonoJitInfoTable * volatile * D.20822;
  struct MonoJitInfo * (*<T2432>) (struct MonoDomain *, struct MonoImage *, void *) jit_info_find_in_aot_func.1;
  struct MonoImage * D.20826;
  struct MonoJitInfoTable * table;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * module_ji;
  struct MonoThreadHazardPointers * hp;

  hp = mono_hazard_pointer_get ();
  D.20804 = mono_stats.jit_info_table_lookup_count;
  D.20805 = D.20804 + 1;
  mono_stats.jit_info_table_lookup_count = D.20805;
  D.20806 = &domain->jit_info_table;
  table = get_hazardous_pointer (D.20806, hp, 0);
  ji = jit_info_table_find (table, hp, addr);
  if (hp != 0B) goto <D.20807>; else goto <D.20808>;
  <D.20807>:
  if (0 != 0) goto <D.20809>; else goto <D.20810>;
  <D.20809>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 401, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.20810>:
  hp->hazard_pointers[0] = 0B;
  <D.20808>:
  if (ji != 0B) goto <D.20811>; else goto <D.20812>;
  <D.20811>:
  D.20813 = ji;
  return D.20813;
  <D.20812>:
  if (try_aot != 0) goto <D.20814>; else goto <D.20815>;
  <D.20814>:
  mono_root_domain.0 = mono_root_domain;
  if (mono_root_domain.0 != 0B) goto <D.20817>; else goto <D.20818>;
  <D.20817>:
  mono_root_domain.0 = mono_root_domain;
  D.20819 = mono_root_domain.0->aot_modules;
  if (D.20819 != 0B) goto <D.20820>; else goto <D.20821>;
  <D.20820>:
  mono_root_domain.0 = mono_root_domain;
  D.20822 = &mono_root_domain.0->aot_modules;
  table = get_hazardous_pointer (D.20822, hp, 0);
  module_ji = jit_info_table_find (table, hp, addr);
  if (module_ji != 0B) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  jit_info_find_in_aot_func.1 = jit_info_find_in_aot_func;
  D.20826 = module_ji->d.image;
  ji = jit_info_find_in_aot_func.1 (domain, D.20826, addr);
  <D.20824>:
  if (hp != 0B) goto <D.20827>; else goto <D.20828>;
  <D.20827>:
  if (0 != 0) goto <D.20829>; else goto <D.20830>;
  <D.20829>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 412, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.20830>:
  hp->hazard_pointers[0] = 0B;
  <D.20828>:
  <D.20821>:
  <D.20818>:
  <D.20815>:
  D.20813 = ji;
  return D.20813;
}


jit_info_table_find (struct MonoJitInfoTable * table, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.20832;
  _Bool D.20833;
  long int D.20834;
  long int D.20835;
  struct MonoJitInfoTableChunk * D.20838;
  struct MonoJitInfo * volatile * D.20839;
  struct MonoMethod * D.20840;
  void * D.20845;
  int D.20848;
  sizetype D.20849;
  gint8 * D.20850;
  struct MonoJitInfo * D.20855;
  int D.20857;
  struct MonoJitInfo * ji;
  int chunk_pos;
  int pos;
  void not_found = <<< error >>>;

  chunk_pos = jit_info_table_index (table, addr);
  D.20832 = table->num_chunks;
  D.20833 = D.20832 <= chunk_pos;
  D.20834 = (long int) D.20833;
  D.20835 = __builtin_expect (D.20834, 0);
  if (D.20835 != 0) goto <D.20836>; else goto <D.20837>;
  <D.20836>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 327, "chunk_pos < table->num_chunks");
  <D.20837>:
  D.20838 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.20838, hp, addr);
  <D.20051>:
  {
    struct MonoJitInfoTableChunk * chunk;

    chunk = table->chunks[chunk_pos];
    goto <D.20047>;
    <D.20049>:
    D.20839 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.20839, hp, 1);
    pos = pos + 1;
    D.20840 = ji->d.method;
    if (D.20840 == 0B) goto <D.20841>; else goto <D.20842>;
    <D.20841>:
    if (0 != 0) goto <D.20843>; else goto <D.20844>;
    <D.20843>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 345, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.20844>:
    hp->hazard_pointers[1] = 0B;
    // predicted unlikely by continue predictor.
    goto <D.20047>;
    <D.20842>:
    D.20845 = ji->code_start;
    if (D.20845 <= addr) goto <D.20846>; else goto <D.20847>;
    <D.20846>:
    D.20845 = ji->code_start;
    D.20848 = ji->code_size;
    D.20849 = (sizetype) D.20848;
    D.20850 = D.20845 + D.20849;
    if (D.20850 > addr) goto <D.20851>; else goto <D.20852>;
    <D.20851>:
    if (0 != 0) goto <D.20853>; else goto <D.20854>;
    <D.20853>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 350, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.20854>:
    hp->hazard_pointers[1] = 0B;
    D.20855 = ji;
    return D.20855;
    <D.20852>:
    <D.20847>:
    D.20845 = ji->code_start;
    if (D.20845 > addr) goto not_found; else goto <D.20856>;
    <D.20856>:
    <D.20047>:
    D.20857 = chunk->num_elements;
    if (D.20857 > pos) goto <D.20049>; else goto <D.20050>;
    <D.20050>:
    chunk_pos = chunk_pos + 1;
    pos = 0;
  }
  D.20832 = table->num_chunks;
  if (D.20832 > chunk_pos) goto <D.20051>; else goto <D.20052>;
  <D.20052>:
  not_found:
  if (hp != 0B) goto <D.20858>; else goto <D.20859>;
  <D.20858>:
  if (0 != 0) goto <D.20860>; else goto <D.20861>;
  <D.20860>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 367, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.20861>:
  hp->hazard_pointers[1] = 0B;
  <D.20859>:
  D.20855 = 0B;
  return D.20855;
}


jit_info_table_index (struct MonoJitInfoTable * table, gint8 * addr)
{
  _Bool D.20863;
  long int D.20864;
  long int D.20865;
  int D.20868;
  volatile gint8 * D.20869;
  _Bool D.20873;
  long int D.20874;
  long int D.20875;
  int D.20878;
  int D.20881;
  int left;
  int right;

  left = 0;
  right = table->num_chunks;
  D.20863 = left >= right;
  D.20864 = (long int) D.20863;
  D.20865 = __builtin_expect (D.20864, 0);
  if (D.20865 != 0) goto <D.20866>; else goto <D.20867>;
  <D.20866>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 282, "left < right");
  <D.20867>:
  <D.20023>:
  {
    int pos;
    struct MonoJitInfoTableChunk * chunk;

    D.20868 = left + right;
    pos = D.20868 / 2;
    chunk = table->chunks[pos];
    D.20869 = chunk->last_code_end;
    if (D.20869 > addr) goto <D.20870>; else goto <D.20871>;
    <D.20870>:
    right = pos;
    goto <D.20872>;
    <D.20871>:
    left = pos + 1;
    <D.20872>:
  }
  if (left < right) goto <D.20023>; else goto <D.20024>;
  <D.20024>:
  D.20873 = left != right;
  D.20874 = (long int) D.20873;
  D.20875 = __builtin_expect (D.20874, 0);
  if (D.20875 != 0) goto <D.20876>; else goto <D.20877>;
  <D.20876>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 293, "left == right");
  <D.20877>:
  D.20878 = table->num_chunks;
  if (D.20878 <= left) goto <D.20879>; else goto <D.20880>;
  <D.20879>:
  D.20878 = table->num_chunks;
  D.20881 = D.20878 + -1;
  return D.20881;
  <D.20880>:
  D.20881 = left;
  return D.20881;
}


jit_info_table_chunk_index (struct MonoJitInfoTableChunk * chunk, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.20883;
  struct MonoJitInfo * volatile * D.20884;
  void * D.20885;
  int D.20886;
  sizetype D.20887;
  _Bool D.20891;
  long int D.20892;
  long int D.20893;
  int D.20896;
  int left;
  int right;

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

    D.20883 = left + right;
    pos = D.20883 / 2;
    D.20884 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.20884, hp, 1);
    D.20885 = ji->code_start;
    D.20886 = ji->code_size;
    D.20887 = (sizetype) D.20886;
    code_end = D.20885 + D.20887;
    if (addr < code_end) goto <D.20888>; else goto <D.20889>;
    <D.20888>:
    right = pos;
    goto <D.20890>;
    <D.20889>:
    left = pos + 1;
    <D.20890>:
  }
  <D.20036>:
  if (left < right) goto <D.20035>; else goto <D.20037>;
  <D.20037>:
  D.20891 = left != right;
  D.20892 = (long int) D.20891;
  D.20893 = __builtin_expect (D.20892, 0);
  if (D.20893 != 0) goto <D.20894>; else goto <D.20895>;
  <D.20894>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 315, "left == right");
  <D.20895>:
  D.20896 = left;
  return D.20896;
}


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

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


mono_jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  struct MonoMethod * D.20900;
  _Bool D.20901;
  long int D.20902;
  long int D.20903;
  union mono_mutex_t * D.20906;
  _Bool D.20909;
  long int D.20910;
  long int D.20911;
  long unsigned int D.20914;
  long unsigned int D.20915;
  struct MonoJitInfoTable * volatile * D.20916;
  _Bool D.20919;
  long int D.20920;
  long int D.20921;

  D.20900 = ji->d.method;
  D.20901 = D.20900 == 0B;
  D.20902 = (long int) D.20901;
  D.20903 = __builtin_expect (D.20902, 0);
  if (D.20903 != 0) goto <D.20904>; else goto <D.20905>;
  <D.20904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 749, "ji->d.method != NULL");
  <D.20905>:
  {
    int ret;

    D.20906 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20906);
    if (ret != 0) goto <D.20907>; else goto <D.20908>;
    <D.20907>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20908>:
    D.20909 = ret != 0;
    D.20910 = (long int) D.20909;
    D.20911 = __builtin_expect (D.20910, 0);
    if (D.20911 != 0) goto <D.20912>; else goto <D.20913>;
    <D.20912>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 751, "ret == 0");
    <D.20913>:
  }
  D.20914 = mono_stats.jit_info_table_insert_count;
  D.20915 = D.20914 + 1;
  mono_stats.jit_info_table_insert_count = D.20915;
  D.20916 = &domain->jit_info_table;
  jit_info_table_add (domain, D.20916, ji);
  {
    int ret;

    D.20906 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20906);
    if (ret != 0) goto <D.20917>; else goto <D.20918>;
    <D.20917>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20918>:
    D.20919 = ret != 0;
    D.20920 = (long int) D.20919;
    D.20921 = __builtin_expect (D.20920, 0);
    if (D.20921 != 0) goto <D.20922>; else goto <D.20923>;
    <D.20922>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 757, "ret == 0");
    <D.20923>:
  }
}


jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfoTable * volatile * table_ptr, struct MonoJitInfo * ji)
{
  void * D.20924;
  int D.20925;
  sizetype D.20926;
  gint8 * D.20927;
  int D.20928;
  _Bool D.20929;
  long int D.20930;
  long int D.20931;
  int D.20934;
  int D.20937;
  int D.20938;
  int D.20941;
  struct MonoJitInfo * D.20942;
  int D.20944;
  struct MonoJitInfo * D.20945;
  int D.20946;
  int D.20947;
  struct MonoJitInfo * D.20948;
  void * D.20949;
  int D.20950;
  int D.20951;
  struct MonoJitInfo * D.20952;
  int D.20953;
  sizetype D.20954;
  volatile gint8 * D.20955;
  struct MonoJitInfoTable * table;
  struct MonoJitInfoTableChunk * chunk;
  int chunk_pos;
  int pos;
  int num_elements;
  int i;
  void restart = <<< error >>>;

  table = *table_ptr;
  restart:
  D.20924 = ji->code_start;
  D.20925 = ji->code_size;
  D.20926 = (sizetype) D.20925;
  D.20927 = D.20924 + D.20926;
  chunk_pos = jit_info_table_index (table, D.20927);
  D.20928 = table->num_chunks;
  D.20929 = D.20928 <= chunk_pos;
  D.20930 = (long int) D.20929;
  D.20931 = __builtin_expect (D.20930, 0);
  if (D.20931 != 0) goto <D.20932>; else goto <D.20933>;
  <D.20932>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 693, "chunk_pos < table->num_chunks");
  <D.20933>:
  chunk = table->chunks[chunk_pos];
  D.20934 = chunk->num_elements;
  if (D.20934 > 63) goto <D.20935>; else goto <D.20936>;
  <D.20935>:
  {
    struct MonoJitInfoTable * new_table;

    new_table = jit_info_table_chunk_overflow (table, chunk);
    *table_ptr = new_table;
    mono_memory_barrier ();
    D.20937 = domain->num_jit_info_tables;
    D.20938 = D.20937 + 1;
    domain->num_jit_info_tables = D.20938;
    mono_thread_hazardous_free_or_queue (table, jit_info_table_free, 1, 0);
    table = new_table;
    goto restart;
  }
  <D.20936>:
  num_elements = chunk->num_elements;
  D.20924 = ji->code_start;
  D.20925 = ji->code_size;
  D.20926 = (sizetype) D.20925;
  D.20927 = D.20924 + D.20926;
  pos = jit_info_table_chunk_index (chunk, 0B, D.20927);
  if (num_elements > 0) goto <D.20939>; else goto <D.20940>;
  <D.20939>:
  D.20941 = num_elements + -1;
  D.20942 = chunk->data[D.20941];
  chunk->data[num_elements] = D.20942;
  goto <D.20943>;
  <D.20940>:
  chunk->data[0] = ji;
  <D.20943>:
  mono_memory_write_barrier ();
  num_elements = num_elements + 1;
  chunk->num_elements = num_elements;
  i = num_elements + -2;
  goto <D.20170>;
  <D.20169>:
  mono_memory_write_barrier ();
  D.20944 = i + 1;
  D.20945 = chunk->data[i];
  chunk->data[D.20944] = D.20945;
  i = i + -1;
  <D.20170>:
  if (i >= pos) goto <D.20169>; else goto <D.20171>;
  <D.20171>:
  mono_memory_write_barrier ();
  chunk->data[pos] = ji;
  D.20946 = chunk->num_elements;
  D.20947 = D.20946 + -1;
  D.20948 = chunk->data[D.20947];
  D.20949 = D.20948->code_start;
  D.20950 = chunk->num_elements;
  D.20951 = D.20950 + -1;
  D.20952 = chunk->data[D.20951];
  D.20953 = D.20952->code_size;
  D.20954 = (sizetype) D.20953;
  D.20955 = D.20949 + D.20954;
  chunk->last_code_end = D.20955;
}


jit_info_table_free (struct MonoJitInfoTable * table)
{
  union mono_mutex_t * D.20956;
  _Bool D.20959;
  long int D.20960;
  long int D.20961;
  struct MonoDomain * D.20964;
  int D.20965;
  int D.20966;
  void * D.20969;
  struct GSList * D.20970;
  int D.20971;
  int D.20972;
  struct MonoMethod * D.20975;
  _Bool D.20980;
  long int D.20981;
  long int D.20982;
  int i;
  int num_chunks;
  struct MonoDomain * domain;

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

    D.20956 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20956);
    if (ret != 0) goto <D.20957>; else goto <D.20958>;
    <D.20957>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20958>:
    D.20959 = ret != 0;
    D.20960 = (long int) D.20959;
    D.20961 = __builtin_expect (D.20960, 0);
    if (D.20961 != 0) goto <D.20962>; else goto <D.20963>;
    <D.20962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 216, "ret == 0");
    <D.20963>:
  }
  D.20964 = table->domain;
  D.20965 = D.20964->num_jit_info_tables;
  D.20966 = D.20965 + -1;
  D.20964->num_jit_info_tables = D.20966;
  D.20964 = table->domain;
  D.20965 = D.20964->num_jit_info_tables;
  if (D.20965 <= 1) goto <D.20967>; else goto <D.20968>;
  <D.20967>:
  {
    struct GSList * list;

    D.20964 = table->domain;
    list = D.20964->jit_info_free_queue;
    goto <D.20001>;
    <D.20000>:
    D.20969 = list->data;
    monoeg_g_free (D.20969);
    list = list->next;
    <D.20001>:
    if (list != 0B) goto <D.20000>; else goto <D.20002>;
    <D.20002>:
    D.20964 = table->domain;
    D.20970 = D.20964->jit_info_free_queue;
    monoeg_g_slist_free (D.20970);
    D.20964 = table->domain;
    D.20964->jit_info_free_queue = 0B;
  }
  <D.20968>:
  i = 0;
  goto <D.20012>;
  <D.20011>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int num_elements;
    int j;

    chunk = table->chunks[i];
    D.20971 = chunk->refcount;
    D.20972 = D.20971 + -1;
    chunk->refcount = D.20972;
    D.20971 = chunk->refcount;
    if (D.20971 > 0) goto <D.20973>; else goto <D.20974>;
    <D.20973>:
    // predicted unlikely by continue predictor.
    goto <D.20006>;
    <D.20974>:
    num_elements = chunk->num_elements;
    j = 0;
    goto <D.20009>;
    <D.20008>:
    {
      struct MonoJitInfo * ji;

      ji = chunk->data[j];
      D.20975 = ji->d.method;
      if (D.20975 == 0B) goto <D.20976>; else goto <D.20977>;
      <D.20976>:
      monoeg_g_free (ji);
      <D.20977>:
    }
    j = j + 1;
    <D.20009>:
    if (j < num_elements) goto <D.20008>; else goto <D.20010>;
    <D.20010>:
    monoeg_g_free (chunk);
  }
  <D.20006>:
  i = i + 1;
  <D.20012>:
  if (i < num_chunks) goto <D.20011>; else goto <D.20013>;
  <D.20013>:
  {
    int ret;

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


jit_info_table_chunk_overflow (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.20987;
  int D.20988;
  int D.20990;
  int D.20991;
  struct MonoJitInfoTable * D.20992;
  struct MonoJitInfo * D.20993;
  struct MonoMethod * D.20994;
  int D.20997;
  int num_elements;
  int i;

  num_elements = jit_info_table_num_elements (table);
  D.20987 = table->num_chunks;
  D.20988 = D.20987 * 32;
  if (D.20988 > num_elements) goto <D.20985>; else goto <D.20989>;
  <D.20989>:
  D.20987 = table->num_chunks;
  D.20990 = D.20987 * 320;
  D.20991 = D.20990 / 6;
  if (D.20991 < num_elements) goto <D.20985>; else goto <D.20986>;
  <D.20985>:
  D.20992 = jit_info_table_realloc (table);
  return D.20992;
  <D.20986>:
  num_elements = 0;
  i = 0;
  goto <D.20154>;
  <D.20153>:
  D.20993 = chunk->data[i];
  D.20994 = D.20993->d.method;
  if (D.20994 != 0B) goto <D.20995>; else goto <D.20996>;
  <D.20995>:
  num_elements = num_elements + 1;
  <D.20996>:
  i = i + 1;
  <D.20154>:
  D.20997 = chunk->num_elements;
  if (D.20997 > i) goto <D.20153>; else goto <D.20155>;
  <D.20155>:
  if (num_elements == 64) goto <D.20998>; else goto <D.20999>;
  <D.20998>:
  D.20992 = jit_info_table_copy_and_split_chunk (table, chunk);
  return D.20992;
  <D.20999>:
  D.20992 = jit_info_table_copy_and_purify_chunk (table, chunk);
  return D.20992;
}


jit_info_table_num_elements (struct MonoJitInfoTable * table)
{
  struct MonoJitInfo * D.21001;
  struct MonoMethod * D.21002;
  int D.21005;
  int D.21006;
  int i;
  int num_elements;

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

    chunk = table->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.19979>;
    <D.19978>:
    D.21001 = chunk->data[j];
    D.21002 = D.21001->d.method;
    if (D.21002 != 0B) goto <D.21003>; else goto <D.21004>;
    <D.21003>:
    num_elements = num_elements + 1;
    <D.21004>:
    j = j + 1;
    <D.19979>:
    if (j < chunk_num_elements) goto <D.19978>; else goto <D.19980>;
    <D.19980>:
  }
  i = i + 1;
  <D.19982>:
  D.21005 = table->num_chunks;
  if (D.21005 > i) goto <D.19981>; else goto <D.19983>;
  <D.19983>:
  D.21006 = num_elements;
  return D.21006;
}


jit_info_table_realloc (struct MonoJitInfoTable * old)
{
  long int D.21008;
  int D.21009;
  _Bool D.21012;
  long int D.21013;
  long int D.21014;
  struct MonoJitInfoTable * D.21017;
  struct MonoDomain * D.21018;
  _Bool D.21019;
  long int D.21020;
  long int D.21021;
  unsigned int num_chunks.2;
  unsigned int D.21025;
  unsigned int D.21026;
  struct MonoJitInfoTableChunk * D.21027;
  struct MonoJitInfo * D.21028;
  struct MonoMethod * D.21029;
  _Bool D.21032;
  long int D.21033;
  long int D.21034;
  struct MonoJitInfoTableChunk * D.21037;
  struct MonoJitInfo * D.21038;
  int D.21041;
  int D.21044;
  _Bool D.21045;
  long int D.21046;
  long int D.21047;
  int D.21050;
  _Bool D.21051;
  long int D.21052;
  long int D.21053;
  int D.21056;
  int D.21057;
  struct MonoJitInfoTableChunk * D.21058;
  void * D.21059;
  int D.21060;
  sizetype D.21061;
  volatile gint8 * D.21062;
  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.21008 = num_elements * 4;
  required_size = D.21008 / 3;
  D.21009 = required_size + 63;
  num_chunks = D.21009 / 64;
  if (num_chunks == 0) goto <D.21010>; else goto <D.21011>;
  <D.21010>:
  D.21012 = num_elements != 0;
  D.21013 = (long int) D.21012;
  D.21014 = __builtin_expect (D.21013, 0);
  if (D.21014 != 0) goto <D.21015>; else goto <D.21016>;
  <D.21015>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 480, "num_elements == 0");
  <D.21016>:
  D.21018 = old->domain;
  D.21017 = jit_info_table_new (D.21018);
  return D.21017;
  <D.21011>:
  D.21019 = num_chunks <= 0;
  D.21020 = (long int) D.21019;
  D.21021 = __builtin_expect (D.21020, 0);
  if (D.21021 != 0) goto <D.21022>; else goto <D.21023>;
  <D.21022>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 483, "num_chunks > 0");
  <D.21023>:
  num_chunks.2 = (unsigned int) num_chunks;
  D.21025 = num_chunks.2 + 2;
  D.21026 = D.21025 * 4;
  new = monoeg_malloc (D.21026);
  D.21018 = old->domain;
  new->domain = D.21018;
  new->num_chunks = num_chunks;
  i = 0;
  goto <D.20095>;
  <D.20094>:
  D.21027 = jit_info_table_new_chunk ();
  new->chunks[i] = D.21027;
  i = i + 1;
  <D.20095>:
  if (i < num_chunks) goto <D.20094>; else goto <D.20096>;
  <D.20096>:
  new_chunk = 0;
  new_element = 0;
  i = 0;
  goto <D.20104>;
  <D.20103>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = old->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.20101>;
    <D.20100>:
    D.21028 = chunk->data[j];
    D.21029 = D.21028->d.method;
    if (D.21029 != 0B) goto <D.21030>; else goto <D.21031>;
    <D.21030>:
    D.21032 = new_chunk >= num_chunks;
    D.21033 = (long int) D.21032;
    D.21034 = __builtin_expect (D.21033, 0);
    if (D.21034 != 0) goto <D.21035>; else goto <D.21036>;
    <D.21035>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 501, "new_chunk < num_chunks");
    <D.21036>:
    D.21037 = new->chunks[new_chunk];
    D.21038 = chunk->data[j];
    D.21037->data[new_element] = D.21038;
    new_element = new_element + 1;
    if (new_element > 47) goto <D.21039>; else goto <D.21040>;
    <D.21039>:
    D.21037 = new->chunks[new_chunk];
    D.21037->num_elements = new_element;
    new_chunk = new_chunk + 1;
    new_element = 0;
    <D.21040>:
    <D.21031>:
    j = j + 1;
    <D.20101>:
    if (j < chunk_num_elements) goto <D.20100>; else goto <D.20102>;
    <D.20102>:
  }
  i = i + 1;
  <D.20104>:
  D.21041 = old->num_chunks;
  if (D.21041 > i) goto <D.20103>; else goto <D.20105>;
  <D.20105>:
  if (new_chunk < num_chunks) goto <D.21042>; else goto <D.21043>;
  <D.21042>:
  D.21044 = num_chunks + -1;
  D.21045 = D.21044 != new_chunk;
  D.21046 = (long int) D.21045;
  D.21047 = __builtin_expect (D.21046, 0);
  if (D.21047 != 0) goto <D.21048>; else goto <D.21049>;
  <D.21048>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 513, "new_chunk == num_chunks - 1");
  <D.21049>:
  D.21037 = new->chunks[new_chunk];
  D.21037->num_elements = new_element;
  D.21037 = new->chunks[new_chunk];
  D.21050 = D.21037->num_elements;
  D.21051 = D.21050 <= 0;
  D.21052 = (long int) D.21051;
  D.21053 = __builtin_expect (D.21052, 0);
  if (D.21053 != 0) goto <D.21054>; else goto <D.21055>;
  <D.21054>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 515, "new->chunks [new_chunk]->num_elements > 0");
  <D.21055>:
  <D.21043>:
  i = 0;
  goto <D.20109>;
  <D.20108>:
  {
    struct MonoJitInfoTableChunk * chunk;
    struct MonoJitInfo * ji;

    chunk = new->chunks[i];
    D.21056 = chunk->num_elements;
    D.21057 = D.21056 + -1;
    ji = chunk->data[D.21057];
    D.21058 = new->chunks[i];
    D.21059 = ji->code_start;
    D.21060 = ji->code_size;
    D.21061 = (sizetype) D.21060;
    D.21062 = D.21059 + D.21061;
    D.21058->last_code_end = D.21062;
  }
  i = i + 1;
  <D.20109>:
  if (i < num_chunks) goto <D.20108>; else goto <D.20110>;
  <D.20110>:
  D.21017 = new;
  return D.21017;
}


jit_info_table_new (struct MonoDomain * domain)
{
  struct MonoJitInfoTableChunk * D.21064;
  struct MonoJitInfoTable * D.21065;
  struct MonoJitInfoTable * table;

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


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

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


jit_info_table_copy_and_split_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.21069;
  unsigned int D.21070;
  unsigned int D.21071;
  unsigned int D.21072;
  struct MonoDomain * D.21073;
  int D.21074;
  struct MonoJitInfoTableChunk * D.21075;
  struct MonoJitInfoTableChunk * * D.21078;
  int D.21079;
  struct MonoJitInfoTableChunk * * D.21080;
  struct MonoJitInfoTableChunk * D.21082;
  int D.21083;
  int D.21084;
  int D.21085;
  _Bool D.21086;
  long int D.21087;
  long int D.21088;
  struct MonoJitInfoTable * D.21091;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.21069 = table->num_chunks;
  D.21070 = (unsigned int) D.21069;
  D.21071 = D.21070 + 3;
  D.21072 = D.21071 * 4;
  new_table = monoeg_malloc (D.21072);
  D.21073 = table->domain;
  new_table->domain = D.21073;
  D.21069 = table->num_chunks;
  D.21074 = D.21069 + 1;
  new_table->num_chunks = D.21074;
  j = 0;
  i = 0;
  goto <D.20126>;
  <D.20125>:
  D.21075 = table->chunks[i];
  if (D.21075 == chunk) goto <D.21076>; else goto <D.21077>;
  <D.21076>:
  D.21078 = &new_table->chunks[j];
  D.21079 = j + 1;
  D.21080 = &new_table->chunks[D.21079];
  jit_info_table_split_chunk (chunk, D.21078, D.21080);
  j = j + 2;
  goto <D.21081>;
  <D.21077>:
  D.21075 = table->chunks[i];
  new_table->chunks[j] = D.21075;
  D.21082 = new_table->chunks[j];
  D.21083 = D.21082->refcount;
  D.21084 = D.21083 + 1;
  D.21082->refcount = D.21084;
  j = j + 1;
  <D.21081>:
  i = i + 1;
  <D.20126>:
  D.21069 = table->num_chunks;
  if (D.21069 > i) goto <D.20125>; else goto <D.20127>;
  <D.20127>:
  D.21085 = new_table->num_chunks;
  D.21086 = D.21085 != j;
  D.21087 = (long int) D.21086;
  D.21088 = __builtin_expect (D.21087, 0);
  if (D.21088 != 0) goto <D.21089>; else goto <D.21090>;
  <D.21089>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 573, "j == new_table->num_chunks");
  <D.21090>:
  D.21091 = new_table;
  return D.21091;
}


jit_info_table_split_chunk (struct MonoJitInfoTableChunk * chunk, struct MonoJitInfoTableChunk * * new1p, struct MonoJitInfoTableChunk * * new2p)
{
  int D.21093;
  _Bool D.21094;
  long int D.21095;
  long int D.21096;
  int D.21099;
  int D.21100;
  struct MonoJitInfo * volatile[64] * D.21101;
  struct MonoJitInfo * volatile[64] * D.21102;
  int D.21103;
  unsigned int D.21104;
  unsigned int D.21105;
  struct MonoJitInfo * volatile[64] * D.21106;
  int D.21107;
  sizetype D.21108;
  struct MonoJitInfo * volatile * D.21109;
  int D.21110;
  unsigned int D.21111;
  unsigned int D.21112;
  int D.21113;
  int D.21114;
  struct MonoJitInfo * D.21115;
  void * D.21116;
  int D.21117;
  int D.21118;
  struct MonoJitInfo * D.21119;
  int D.21120;
  sizetype D.21121;
  volatile gint8 * D.21122;
  int D.21123;
  int D.21124;
  struct MonoJitInfo * D.21125;
  void * D.21126;
  int D.21127;
  int D.21128;
  struct MonoJitInfo * D.21129;
  int D.21130;
  sizetype D.21131;
  volatile gint8 * D.21132;
  struct MonoJitInfoTableChunk * new1;
  struct MonoJitInfoTableChunk * new2;

  new1 = jit_info_table_new_chunk ();
  new2 = jit_info_table_new_chunk ();
  D.21093 = chunk->num_elements;
  D.21094 = D.21093 != 64;
  D.21095 = (long int) D.21094;
  D.21096 = __builtin_expect (D.21095, 0);
  if (D.21096 != 0) goto <D.21097>; else goto <D.21098>;
  <D.21097>:
  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.21098>:
  new1->num_elements = 32;
  D.21099 = new1->num_elements;
  D.21100 = 64 - D.21099;
  new2->num_elements = D.21100;
  D.21101 = &new1->data;
  D.21102 = &chunk->data;
  D.21103 = new1->num_elements;
  D.21104 = (unsigned int) D.21103;
  D.21105 = D.21104 * 4;
  memcpy (D.21101, D.21102, D.21105);
  D.21106 = &new2->data;
  D.21107 = new1->num_elements;
  D.21108 = (sizetype) D.21107;
  D.21109 = &chunk->data[D.21108];
  D.21110 = new2->num_elements;
  D.21111 = (unsigned int) D.21110;
  D.21112 = D.21111 * 4;
  memcpy (D.21106, D.21109, D.21112);
  D.21113 = new1->num_elements;
  D.21114 = D.21113 + -1;
  D.21115 = new1->data[D.21114];
  D.21116 = D.21115->code_start;
  D.21117 = new1->num_elements;
  D.21118 = D.21117 + -1;
  D.21119 = new1->data[D.21118];
  D.21120 = D.21119->code_size;
  D.21121 = (sizetype) D.21120;
  D.21122 = D.21116 + D.21121;
  new1->last_code_end = D.21122;
  D.21123 = new2->num_elements;
  D.21124 = D.21123 + -1;
  D.21125 = new2->data[D.21124];
  D.21126 = D.21125->code_start;
  D.21127 = new2->num_elements;
  D.21128 = D.21127 + -1;
  D.21129 = new2->data[D.21128];
  D.21130 = D.21129->code_size;
  D.21131 = (sizetype) D.21130;
  D.21132 = D.21126 + D.21131;
  new2->last_code_end = D.21132;
  *new1p = new1;
  *new2p = new2;
}


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

  D.21134 = __builtin_object_size (__dest, 0);
  D.21133 = __builtin___memcpy_chk (__dest, __src, __len, D.21134);
  return D.21133;
}


jit_info_table_copy_and_purify_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.21136;
  unsigned int D.21137;
  unsigned int D.21138;
  unsigned int D.21139;
  struct MonoDomain * D.21140;
  struct MonoJitInfoTableChunk * D.21141;
  int j.3;
  struct MonoJitInfoTableChunk * D.21145;
  struct MonoJitInfoTableChunk * D.21147;
  int D.21148;
  int D.21149;
  int D.21150;
  _Bool D.21151;
  long int D.21152;
  long int D.21153;
  struct MonoJitInfoTable * D.21156;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.21136 = table->num_chunks;
  D.21137 = (unsigned int) D.21136;
  D.21138 = D.21137 + 2;
  D.21139 = D.21138 * 4;
  new_table = monoeg_malloc (D.21139);
  D.21140 = table->domain;
  new_table->domain = D.21140;
  D.21136 = table->num_chunks;
  new_table->num_chunks = D.21136;
  j = 0;
  i = 0;
  goto <D.20145>;
  <D.20144>:
  D.21141 = table->chunks[i];
  if (D.21141 == chunk) goto <D.21142>; else goto <D.21143>;
  <D.21142>:
  j.3 = j;
  j = j.3 + 1;
  D.21141 = table->chunks[i];
  D.21145 = jit_info_table_purify_chunk (D.21141);
  new_table->chunks[j.3] = D.21145;
  goto <D.21146>;
  <D.21143>:
  D.21141 = table->chunks[i];
  new_table->chunks[j] = D.21141;
  D.21147 = new_table->chunks[j];
  D.21148 = D.21147->refcount;
  D.21149 = D.21148 + 1;
  D.21147->refcount = D.21149;
  j = j + 1;
  <D.21146>:
  i = i + 1;
  <D.20145>:
  D.21136 = table->num_chunks;
  if (D.21136 > i) goto <D.20144>; else goto <D.20146>;
  <D.20146>:
  D.21150 = new_table->num_chunks;
  D.21151 = D.21150 != j;
  D.21152 = (long int) D.21151;
  D.21153 = __builtin_expect (D.21152, 0);
  if (D.21153 != 0) goto <D.21154>; else goto <D.21155>;
  <D.21154>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 620, "j == new_table->num_chunks");
  <D.21155>:
  D.21156 = new_table;
  return D.21156;
}


jit_info_table_purify_chunk (struct MonoJitInfoTableChunk * old)
{
  struct MonoJitInfo * D.21158;
  struct MonoMethod * D.21159;
  int j.4;
  struct MonoJitInfo * D.21163;
  int D.21164;
  int D.21165;
  int D.21168;
  struct MonoJitInfo * D.21169;
  void * D.21170;
  struct MonoJitInfo * D.21171;
  int D.21172;
  sizetype D.21173;
  volatile gint8 * D.21174;
  volatile gint8 * D.21176;
  struct MonoJitInfoTableChunk * D.21177;
  struct MonoJitInfoTableChunk * new;
  int i;
  int j;

  new = jit_info_table_new_chunk ();
  j = 0;
  i = 0;
  goto <D.20135>;
  <D.20134>:
  D.21158 = old->data[i];
  D.21159 = D.21158->d.method;
  if (D.21159 != 0B) goto <D.21160>; else goto <D.21161>;
  <D.21160>:
  j.4 = j;
  j = j.4 + 1;
  D.21163 = old->data[i];
  new->data[j.4] = D.21163;
  <D.21161>:
  i = i + 1;
  <D.20135>:
  D.21164 = old->num_elements;
  if (D.21164 > i) goto <D.20134>; else goto <D.20136>;
  <D.20136>:
  new->num_elements = j;
  D.21165 = new->num_elements;
  if (D.21165 > 0) goto <D.21166>; else goto <D.21167>;
  <D.21166>:
  D.21168 = j + -1;
  D.21169 = new->data[D.21168];
  D.21170 = D.21169->code_start;
  D.21168 = j + -1;
  D.21171 = new->data[D.21168];
  D.21172 = D.21171->code_size;
  D.21173 = (sizetype) D.21172;
  D.21174 = D.21170 + D.21173;
  new->last_code_end = D.21174;
  goto <D.21175>;
  <D.21167>:
  D.21176 = old->last_code_end;
  new->last_code_end = D.21176;
  <D.21175>:
  D.21177 = new;
  return D.21177;
}


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.21179;
  _Bool D.21182;
  long int D.21183;
  long int D.21184;
  long unsigned int D.21187;
  long unsigned int D.21188;
  _Bool D.21191;
  long int D.21192;
  long int D.21193;
  struct MonoJitInfoTable * table;

  {
    int ret;

    D.21179 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21179);
    if (ret != 0) goto <D.21180>; else goto <D.21181>;
    <D.21180>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21181>:
    D.21182 = ret != 0;
    D.21183 = (long int) D.21182;
    D.21184 = __builtin_expect (D.21183, 0);
    if (D.21184 != 0) goto <D.21185>; else goto <D.21186>;
    <D.21185>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 831, "ret == 0");
    <D.21186>:
  }
  table = domain->jit_info_table;
  D.21187 = mono_stats.jit_info_table_remove_count;
  D.21188 = D.21187 + 1;
  mono_stats.jit_info_table_remove_count = D.21188;
  jit_info_table_remove (table, ji);
  mono_jit_info_free_or_queue (domain, ji);
  {
    int ret;

    D.21179 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21179);
    if (ret != 0) goto <D.21189>; else goto <D.21190>;
    <D.21189>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21190>:
    D.21191 = ret != 0;
    D.21192 = (long int) D.21191;
    D.21193 = __builtin_expect (D.21192, 0);
    if (D.21193 != 0) goto <D.21194>; else goto <D.21195>;
    <D.21194>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 840, "ret == 0");
    <D.21195>:
  }
}


jit_info_table_remove (struct MonoJitInfoTable * table, struct MonoJitInfo * ji)
{
  int D.21196;
  _Bool D.21197;
  long int D.21198;
  long int D.21199;
  struct MonoJitInfoTableChunk * D.21202;
  struct MonoJitInfo * D.21203;
  struct MonoJitInfo * D.21205;
  struct MonoMethod * D.21206;
  _Bool D.21207;
  long int D.21208;
  long int D.21209;
  struct MonoJitInfo * D.21212;
  void * D.21213;
  struct MonoJitInfo * D.21214;
  int D.21215;
  sizetype D.21216;
  guint8 * D.21217;
  void * D.21218;
  int D.21219;
  sizetype D.21220;
  guint8 * D.21221;
  _Bool D.21222;
  long int D.21223;
  long int D.21224;
  int D.21227;
  struct MonoJitInfo * D.21228;
  _Bool D.21229;
  long int D.21230;
  long int D.21231;
  struct MonoJitInfo * D.21234;
  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.21196 = table->num_chunks;
  D.21197 = D.21196 <= chunk_pos;
  D.21198 = (long int) D.21197;
  D.21199 = __builtin_expect (D.21198, 0);
  if (D.21199 != 0) goto <D.21200>; else goto <D.21201>;
  <D.21200>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 795, "chunk_pos < table->num_chunks");
  <D.21201>:
  D.21202 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.21202, 0B, start);
  <D.20198>:
  chunk = table->chunks[chunk_pos];
  goto <D.20196>;
  <D.20195>:
  D.21203 = chunk->data[pos];
  if (D.21203 == ji) goto found; else goto <D.21204>;
  <D.21204>:
  D.21205 = chunk->data[pos];
  D.21206 = D.21205->d.method;
  D.21207 = D.21206 != 0B;
  D.21208 = (long int) D.21207;
  D.21209 = __builtin_expect (D.21208, 0);
  if (D.21209 != 0) goto <D.21210>; else goto <D.21211>;
  <D.21210>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 806, "IS_JIT_INFO_TOMBSTONE (chunk->data [pos])");
  <D.21211>:
  D.21212 = chunk->data[pos];
  D.21213 = D.21212->code_start;
  D.21214 = chunk->data[pos];
  D.21215 = D.21214->code_size;
  D.21216 = (sizetype) D.21215;
  D.21217 = D.21213 + D.21216;
  D.21218 = ji->code_start;
  D.21219 = ji->code_size;
  D.21220 = (sizetype) D.21219;
  D.21221 = D.21218 + D.21220;
  D.21222 = D.21217 > D.21221;
  D.21223 = (long int) D.21222;
  D.21224 = __builtin_expect (D.21223, 0);
  if (D.21224 != 0) goto <D.21225>; else goto <D.21226>;
  <D.21225>:
  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.21226>:
  pos = pos + 1;
  <D.20196>:
  D.21227 = chunk->num_elements;
  if (D.21227 > pos) goto <D.20195>; else goto <D.20197>;
  <D.20197>:
  chunk_pos = chunk_pos + 1;
  pos = 0;
  D.21196 = table->num_chunks;
  if (D.21196 > chunk_pos) goto <D.20198>; else goto <D.20199>;
  <D.20199>:
  found:
  D.21228 = chunk->data[pos];
  D.21229 = D.21228 != ji;
  D.21230 = (long int) D.21229;
  D.21231 = __builtin_expect (D.21230, 0);
  if (D.21231 != 0) goto <D.21232>; else goto <D.21233>;
  <D.21232>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 818, "chunk->data [pos] == ji");
  <D.21233>:
  D.21234 = mono_jit_info_make_tombstone (ji);
  chunk->data[pos] = D.21234;
}


mono_jit_info_make_tombstone (struct MonoJitInfo * ji)
{
  void * D.21235;
  int D.21236;
  struct MonoJitInfo * D.21237;
  struct MonoJitInfo * tombstone;

  tombstone = monoeg_malloc0 (28);
  D.21235 = ji->code_start;
  tombstone->code_start = D.21235;
  D.21236 = ji->code_size;
  tombstone->code_size = D.21236;
  tombstone->d.method = 0B;
  D.21237 = tombstone;
  return D.21237;
}


mono_jit_info_free_or_queue (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  int D.21239;
  struct GSList * D.21243;
  struct GSList * D.21244;

  D.21239 = domain->num_jit_info_tables;
  if (D.21239 <= 1) goto <D.21240>; else goto <D.21241>;
  <D.21240>:
  mono_thread_hazardous_free_or_queue (ji, monoeg_g_free, 1, 0);
  goto <D.21242>;
  <D.21241>:
  D.21243 = domain->jit_info_free_queue;
  D.21244 = monoeg_g_slist_prepend (D.21243, ji);
  domain->jit_info_free_queue = D.21244;
  <D.21242>:
}


mono_jit_info_add_aot_module (struct MonoImage * image, void * start, void * end)
{
  _Bool D.21247;
  long int D.21248;
  long int D.21249;
  struct MonoDomain * mono_root_domain.5;
  _Bool D.21253;
  long int D.21254;
  long int D.21255;
  struct MonoJitInfoTable * D.21258;
  int D.21261;
  int D.21262;
  struct MonoJitInfoTable * D.21263;
  int end.6;
  int start.7;
  int D.21266;
  struct MonoJitInfoTable * volatile * D.21267;
  _Bool D.21270;
  long int D.21271;
  long int D.21272;
  struct MonoJitInfo * ji;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21245>; else goto <D.21246>;
    <D.21245>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21246>:
    D.21247 = ret != 0;
    D.21248 = (long int) D.21247;
    D.21249 = __builtin_expect (D.21248, 0);
    if (D.21249 != 0) goto <D.21250>; else goto <D.21251>;
    <D.21250>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 848, "ret == 0");
    <D.21251>:
  }
  mono_root_domain.5 = mono_root_domain;
  D.21253 = mono_root_domain.5 == 0B;
  D.21254 = (long int) D.21253;
  D.21255 = __builtin_expect (D.21254, 0);
  if (D.21255 != 0) goto <D.21256>; else goto <D.21257>;
  <D.21256>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 854, "mono_root_domain");
  <D.21257>:
  mono_root_domain.5 = mono_root_domain;
  D.21258 = mono_root_domain.5->aot_modules;
  if (D.21258 == 0B) goto <D.21259>; else goto <D.21260>;
  <D.21259>:
  mono_root_domain.5 = mono_root_domain;
  D.21261 = mono_root_domain.5->num_jit_info_tables;
  D.21262 = D.21261 + 1;
  mono_root_domain.5->num_jit_info_tables = D.21262;
  mono_root_domain.5 = mono_root_domain;
  mono_root_domain.5 = mono_root_domain;
  D.21263 = jit_info_table_new (mono_root_domain.5);
  mono_root_domain.5->aot_modules = D.21263;
  <D.21260>:
  ji = monoeg_malloc0 (28);
  ji->d.image = image;
  ji->code_start = start;
  end.6 = (int) end;
  start.7 = (int) start;
  D.21266 = end.6 - start.7;
  ji->code_size = D.21266;
  mono_root_domain.5 = mono_root_domain;
  mono_root_domain.5 = mono_root_domain;
  D.21267 = &mono_root_domain.5->aot_modules;
  jit_info_table_add (mono_root_domain.5, D.21267, ji);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21268>; else goto <D.21269>;
    <D.21268>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21269>:
    D.21270 = ret != 0;
    D.21271 = (long int) D.21270;
    D.21272 = __builtin_expect (D.21271, 0);
    if (D.21272 != 0) goto <D.21273>; else goto <D.21274>;
    <D.21273>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 866, "ret == 0");
    <D.21274>:
  }
}


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

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


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

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


mono_jit_info_get_method (struct MonoJitInfo * ji)
{
  unsigned char D.21279;
  unsigned char D.21280;
  _Bool D.21281;
  long int D.21282;
  long int D.21283;
  struct MonoMethod * D.21286;

  D.21279 = BIT_FIELD_REF <*ji, 8, 184>;
  D.21280 = D.21279 & 1;
  D.21281 = D.21280 != 0;
  D.21282 = (long int) D.21281;
  D.21283 = __builtin_expect (D.21282, 0);
  if (D.21283 != 0) goto <D.21284>; else goto <D.21285>;
  <D.21284>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 890, "!ji->async");
  <D.21285>:
  D.21286 = ji->d.method;
  return D.21286;
}


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

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


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

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


mono_jit_info_get_generic_jit_info (struct MonoJitInfo * ji)
{
  unsigned char D.21292;
  unsigned char D.21293;
  struct MonoGenericJitInfo * D.21296;
  <unnamed-unsigned:15> D.21297;
  int D.21298;

  D.21292 = BIT_FIELD_REF <*ji, 8, 176>;
  D.21293 = D.21292 & 2;
  if (D.21293 != 0) goto <D.21294>; else goto <D.21295>;
  <D.21294>:
  D.21297 = ji->num_clauses;
  D.21298 = (int) D.21297;
  D.21296 = &ji->clauses[D.21298];
  return D.21296;
  <D.21295>:
  D.21296 = 0B;
  return D.21296;
}


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

  gi = mono_jit_info_get_generic_jit_info (ji);
  if (gi != 0B) goto <D.21300>; else goto <D.21301>;
  <D.21300>:
  D.21302 = gi->generic_sharing_context;
  return D.21302;
  <D.21301>:
  D.21302 = 0B;
  return D.21302;
}


mono_jit_info_set_generic_sharing_context (struct MonoJitInfo * ji, struct MonoGenericSharingContext * gsctx)
{
  _Bool D.21304;
  long int D.21305;
  long int D.21306;
  struct MonoGenericJitInfo * gi;

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


mono_jit_info_get_try_block_hole_table_info (struct MonoJitInfo * ji)
{
  unsigned char D.21309;
  unsigned char D.21310;
  <unnamed-unsigned:15> D.21313;
  int D.21314;
  unsigned char D.21315;
  struct MonoTryBlockHoleTableJitInfo * D.21318;

  D.21309 = BIT_FIELD_REF <*ji, 8, 176>;
  D.21310 = D.21309 & 4;
  if (D.21310 != 0) goto <D.21311>; else goto <D.21312>;
  <D.21311>:
  {
    char * ptr;

    D.21313 = ji->num_clauses;
    D.21314 = (int) D.21313;
    ptr = &ji->clauses[D.21314];
    D.21309 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21315 = D.21309 & 2;
    if (D.21315 != 0) goto <D.21316>; else goto <D.21317>;
    <D.21316>:
    ptr = ptr + 20;
    <D.21317>:
    D.21318 = ptr;
    return D.21318;
  }
  <D.21312>:
  D.21318 = 0B;
  return D.21318;
}


mono_jit_info_get_arch_eh_info (struct MonoJitInfo * ji)
{
  unsigned char D.21320;
  unsigned char D.21321;
  <unnamed-unsigned:15> D.21324;
  int D.21325;
  unsigned char D.21326;
  unsigned char D.21329;
  struct MonoArchEHJitInfo * D.21332;

  D.21320 = BIT_FIELD_REF <*ji, 8, 176>;
  D.21321 = D.21320 & 8;
  if (D.21321 != 0) goto <D.21322>; else goto <D.21323>;
  <D.21322>:
  {
    char * ptr;

    D.21324 = ji->num_clauses;
    D.21325 = (int) D.21324;
    ptr = &ji->clauses[D.21325];
    D.21320 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21326 = D.21320 & 2;
    if (D.21326 != 0) goto <D.21327>; else goto <D.21328>;
    <D.21327>:
    ptr = ptr + 20;
    <D.21328>:
    D.21320 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21329 = D.21320 & 4;
    if (D.21329 != 0) goto <D.21330>; else goto <D.21331>;
    <D.21330>:
    ptr = ptr + 4;
    <D.21331>:
    D.21332 = ptr;
    return D.21332;
  }
  <D.21323>:
  D.21332 = 0B;
  return D.21332;
}


mono_jit_info_get_cas_info (struct MonoJitInfo * ji)
{
  unsigned char D.21334;
  unsigned char D.21335;
  <unnamed-unsigned:15> D.21338;
  int D.21339;
  unsigned char D.21340;
  unsigned char D.21343;
  unsigned char D.21346;
  struct MonoMethodCasInfo * D.21349;

  D.21334 = BIT_FIELD_REF <*ji, 8, 176>;
  D.21335 = D.21334 & 1;
  if (D.21335 != 0) goto <D.21336>; else goto <D.21337>;
  <D.21336>:
  {
    char * ptr;

    D.21338 = ji->num_clauses;
    D.21339 = (int) D.21338;
    ptr = &ji->clauses[D.21339];
    D.21334 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21340 = D.21334 & 2;
    if (D.21340 != 0) goto <D.21341>; else goto <D.21342>;
    <D.21341>:
    ptr = ptr + 20;
    <D.21342>:
    D.21334 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21343 = D.21334 & 4;
    if (D.21343 != 0) goto <D.21344>; else goto <D.21345>;
    <D.21344>:
    ptr = ptr + 4;
    <D.21345>:
    D.21334 = BIT_FIELD_REF <*ji, 8, 176>;
    D.21346 = D.21334 & 8;
    if (D.21346 != 0) goto <D.21347>; else goto <D.21348>;
    <D.21347>:
    ptr = ptr + 4;
    <D.21348>:
    D.21349 = ptr;
    return D.21349;
  }
  <D.21337>:
  D.21349 = 0B;
  return D.21349;
}


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.21353;
  mono_unichar2 * D.21356;
  mono_unichar2 * D.21357;
  int D.21358;
  unsigned int D.21359;
  int D.21360;
  _Bool D.21361;
  int l1;
  int l2;

  l1 = mono_string_length (s1);
  l2 = mono_string_length (s2);
  if (s1 == s2) goto <D.21351>; else goto <D.21352>;
  <D.21351>:
  D.21353 = 1;
  return D.21353;
  <D.21352>:
  if (l1 != l2) goto <D.21354>; else goto <D.21355>;
  <D.21354>:
  D.21353 = 0;
  return D.21353;
  <D.21355>:
  D.21356 = mono_string_chars (s1);
  D.21357 = mono_string_chars (s2);
  D.21358 = l1 * 2;
  D.21359 = (unsigned int) D.21358;
  D.21360 = memcmp (D.21356, D.21357, D.21359);
  D.21361 = D.21360 == 0;
  D.21353 = (mono_bool) D.21361;
  return D.21353;
}


mono_string_hash (struct MonoString * s)
{
  unsigned int D.21363;
  unsigned int D.21364;
  short unsigned int D.21365;
  unsigned int D.21366;
  unsigned int D.21367;
  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.20312>;
  <D.20311>:
  D.21363 = h << 5;
  D.21364 = D.21363 - h;
  D.21365 = *p;
  D.21366 = (unsigned int) D.21365;
  h = D.21364 + D.21366;
  p = p + 2;
  i = i + 1;
  <D.20312>:
  if (i < len) goto <D.20311>; else goto <D.20313>;
  <D.20313>:
  D.21367 = h;
  return D.21367;
}


mono_domain_create ()
{
  _Bool D.21371;
  long int D.21372;
  long int D.21373;
  unsigned int domain_shadow_serial.8;
  unsigned int domain_shadow_serial.9;
  unsigned int domain_shadow_serial.10;
  void * domain_gc_desc.11;
  unsigned int D.21382;
  unsigned int D.21383;
  int bit.12;
  int D.21385;
  unsigned int D.21386;
  unsigned int D.21387;
  unsigned int D.21388;
  int D.21389;
  void * domain_gc_desc.13;
  _Bool D.21393;
  long int D.21394;
  long int D.21395;
  struct MonoGHashTable * * D.21398;
  int shadow_serial.14;
  struct MonoMemPool * D.21400;
  struct MonoCodeManager * D.21401;
  struct LockFreeMempool * D.21402;
  struct MonoGHashTable * D.21403;
  struct GPtrArray * D.21404;
  struct GHashTable * D.21405;
  struct MonoInternalHashTable * D.21406;
  struct MonoGHashTable * D.21407;
  struct MonoJitInfoTable * D.21408;
  struct GHashTable * D.21409;
  struct GHashTable * D.21410;
  struct CRITICAL_SECTION * D.21411;
  struct CRITICAL_SECTION * D.21412;
  struct CRITICAL_SECTION * D.21413;
  struct CRITICAL_SECTION * D.21414;
  _Bool D.21417;
  long int D.21418;
  long int D.21419;
  _Bool D.21424;
  long int D.21425;
  long int D.21426;
  struct MonoPerfCounters * mono_perfcounters.15;
  unsigned int D.21430;
  unsigned int D.21431;
  unsigned int D.21432;
  unsigned int D.21433;
  void (*<T23b9>) (struct MonoDomain *) create_domain_hook.16;
  struct MonoDomain * D.21437;
  struct MonoDomain * domain;
  guint32 shadow_serial;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21369>; else goto <D.21370>;
    <D.21369>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21370>:
    D.21371 = ret != 0;
    D.21372 = (long int) D.21371;
    D.21373 = __builtin_expect (D.21372, 0);
    if (D.21373 != 0) goto <D.21374>; else goto <D.21375>;
    <D.21374>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1234, "ret == 0");
    <D.21375>:
  }
  domain_shadow_serial.8 = domain_shadow_serial;
  domain_shadow_serial.9 = domain_shadow_serial.8;
  domain_shadow_serial.10 = domain_shadow_serial.9 + 1;
  domain_shadow_serial = domain_shadow_serial.10;
  shadow_serial = domain_shadow_serial.9;
  domain_gc_desc.11 = domain_gc_desc;
  if (domain_gc_desc.11 == 0B) goto <D.21380>; else goto <D.21381>;
  <D.21380>:
  {
    unsigned int i;
    unsigned int bit;

    bit = 0;
    i = 36;
    goto <D.20353>;
    <D.20352>:
    bit = i / 4;
    D.21382 = bit / 32;
    D.21383 = domain_gc_bitmap[D.21382];
    bit.12 = (int) bit;
    D.21385 = bit.12 & 31;
    D.21386 = 1 << D.21385;
    D.21387 = D.21383 | D.21386;
    domain_gc_bitmap[D.21382] = D.21387;
    i = i + 4;
    <D.20353>:
    if (i <= 71) goto <D.20352>; else goto <D.20354>;
    <D.20354>:
    D.21388 = bit + 1;
    D.21389 = (int) D.21388;
    domain_gc_desc.13 = mono_gc_make_descr_from_bitmap (&domain_gc_bitmap, D.21389);
    domain_gc_desc = domain_gc_desc.13;
  }
  <D.21381>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21391>; else goto <D.21392>;
    <D.21391>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21392>:
    D.21393 = ret != 0;
    D.21394 = (long int) D.21393;
    D.21395 = __builtin_expect (D.21394, 0);
    if (D.21395 != 0) goto <D.21396>; else goto <D.21397>;
    <D.21396>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1245, "ret == 0");
    <D.21397>:
  }
  domain_gc_desc.11 = domain_gc_desc;
  domain = mono_gc_alloc_fixed (380, domain_gc_desc.11);
  D.21398 = &domain->env;
  mono_gc_register_root (D.21398, 24, 0B);
  shadow_serial.14 = (int) shadow_serial;
  domain->shadow_serial = shadow_serial.14;
  domain->domain = 0B;
  domain->setup = 0B;
  domain->friendly_name = 0B;
  domain->search_path = 0B;
  mono_profiler_appdomain_event (domain, 0);
  D.21400 = mono_mempool_new ();
  domain->mp = D.21400;
  D.21401 = mono_code_manager_new ();
  domain->code_mp = D.21401;
  D.21402 = lock_free_mempool_new ();
  domain->lock_free_mp = D.21402;
  D.21403 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->env = D.21403;
  domain->domain_assemblies = 0B;
  domain->assembly_bindings = 0B;
  domain->assembly_bindings_parsed = 0;
  D.21404 = monoeg_g_ptr_array_new ();
  domain->class_vtable_array = D.21404;
  D.21405 = monoeg_g_hash_table_new (mono_ptrarray_hash, mono_ptrarray_equal);
  domain->proxy_vtable_hash = D.21405;
  domain->static_data_array = 0B;
  D.21406 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.21406);
  D.21407 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->ldstr_table = D.21407;
  domain->num_jit_info_tables = 1;
  D.21408 = jit_info_table_new (domain);
  domain->jit_info_table = D.21408;
  domain->jit_info_free_queue = 0B;
  D.21409 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->finalizable_objects_hash = D.21409;
  D.21410 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->ftnptrs_hash = D.21410;
  D.21411 = &domain->lock;
  InitializeCriticalSection (D.21411);
  D.21412 = &domain->assemblies_lock;
  InitializeCriticalSection (D.21412);
  D.21413 = &domain->jit_code_hash_lock;
  InitializeCriticalSection (D.21413);
  D.21414 = &domain->finalizable_objects_hash_lock;
  InitializeCriticalSection (D.21414);
  domain->method_rgctx_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21415>; else goto <D.21416>;
    <D.21415>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21416>:
    D.21417 = ret != 0;
    D.21418 = (long int) D.21417;
    D.21419 = __builtin_expect (D.21418, 0);
    if (D.21419 != 0) goto <D.21420>; else goto <D.21421>;
    <D.21420>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1292, "ret == 0");
    <D.21421>:
  }
  domain_id_alloc (domain);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.21422>; else goto <D.21423>;
    <D.21422>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21423>:
    D.21424 = ret != 0;
    D.21425 = (long int) D.21424;
    D.21426 = __builtin_expect (D.21425, 0);
    if (D.21426 != 0) goto <D.21427>; else goto <D.21428>;
    <D.21427>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1294, "ret == 0");
    <D.21428>:
  }
  mono_perfcounters.15 = mono_perfcounters;
  D.21430 = mono_perfcounters.15->loader_appdomains;
  D.21431 = D.21430 + 1;
  mono_perfcounters.15->loader_appdomains = D.21431;
  mono_perfcounters.15 = mono_perfcounters;
  D.21432 = mono_perfcounters.15->loader_total_appdomains;
  D.21433 = D.21432 + 1;
  mono_perfcounters.15->loader_total_appdomains = D.21433;
  mono_debug_domain_create (domain);
  create_domain_hook.16 = create_domain_hook;
  if (create_domain_hook.16 != 0B) goto <D.21435>; else goto <D.21436>;
  <D.21435>:
  create_domain_hook.16 = create_domain_hook;
  create_domain_hook.16 (domain);
  <D.21436>:
  mono_profiler_appdomain_loaded (domain, 0);
  D.21437 = domain;
  return D.21437;
}


mono_ptrarray_equal (void * * s1, void * * s2)
{
  void * D.21439;
  void * D.21440;
  int D.21441;
  gboolean D.21444;
  const void * D.21445;
  const void * D.21446;
  unsigned int len.17;
  unsigned int D.21448;
  int D.21449;
  _Bool D.21450;
  int len;

  D.21439 = *s1;
  len = (int) D.21439;
  D.21440 = *s2;
  D.21441 = (int) D.21440;
  if (D.21441 != len) goto <D.21442>; else goto <D.21443>;
  <D.21442>:
  D.21444 = 0;
  return D.21444;
  <D.21443>:
  D.21445 = s1 + 4;
  D.21446 = s2 + 4;
  len.17 = (unsigned int) len;
  D.21448 = len.17 * 4;
  D.21449 = memcmp (D.21445, D.21446, D.21448);
  D.21450 = D.21449 == 0;
  D.21444 = (gboolean) D.21450;
  return D.21444;
}


mono_ptrarray_hash (void * * s)
{
  void * D.21452;
  unsigned int i.18;
  unsigned int D.21454;
  void * * D.21455;
  void * D.21456;
  unsigned int D.21457;
  guint D.21458;
  int i;
  int len;
  guint hash;

  D.21452 = *s;
  len = (int) D.21452;
  hash = 0;
  i = 1;
  goto <D.20326>;
  <D.20325>:
  i.18 = (unsigned int) i;
  D.21454 = i.18 * 4;
  D.21455 = s + D.21454;
  D.21456 = *D.21455;
  D.21457 = (unsigned int) D.21456;
  hash = D.21457 + hash;
  i = i + 1;
  <D.20326>:
  if (i < len) goto <D.20325>; else goto <D.20327>;
  <D.20327>:
  D.21458 = hash;
  return D.21458;
}


lock_free_mempool_new ()
{
  struct LockFreeMempool * D.21460;

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


domain_id_alloc (struct MonoDomain * domain)
{
  struct MonoDomain * * appdomains_list.19;
  short unsigned int appdomain_list_size.20;
  unsigned int D.21466;
  unsigned int D.21467;
  void * appdomains_list.21;
  short unsigned int appdomain_next.22;
  unsigned int i.23;
  unsigned int D.21471;
  struct MonoDomain * * D.21472;
  struct MonoDomain * D.21473;
  int D.21476;
  int D.21481;
  unsigned int new_size.24;
  unsigned int D.21487;
  short unsigned int appdomain_list_size.25;
  unsigned int id.26;
  unsigned int D.21490;
  struct MonoDomain * * D.21491;
  short unsigned int appdomain_next.27;
  short unsigned int appdomain_next.28;
  int D.21496;
  int id;
  int i;

  id = -1;
  appdomains_list.19 = appdomains_list;
  if (appdomains_list.19 == 0B) goto <D.21463>; else goto <D.21464>;
  <D.21463>:
  appdomain_list_size = 2;
  appdomain_list_size.20 = appdomain_list_size;
  D.21466 = (unsigned int) appdomain_list_size.20;
  D.21467 = D.21466 * 4;
  appdomains_list.21 = mono_gc_alloc_fixed (D.21467, 0B);
  appdomains_list = appdomains_list.21;
  <D.21464>:
  appdomain_next.22 = appdomain_next;
  i = (int) appdomain_next.22;
  goto <D.20335>;
  <D.20334>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.21471 = i.23 * 4;
  D.21472 = appdomains_list.19 + D.21471;
  D.21473 = *D.21472;
  if (D.21473 == 0B) goto <D.21474>; else goto <D.21475>;
  <D.21474>:
  id = i;
  goto <D.20333>;
  <D.21475>:
  i = i + 1;
  <D.20335>:
  appdomain_list_size.20 = appdomain_list_size;
  D.21476 = (int) appdomain_list_size.20;
  if (D.21476 > i) goto <D.20334>; else goto <D.20333>;
  <D.20333>:
  if (id == -1) goto <D.21477>; else goto <D.21478>;
  <D.21477>:
  i = 0;
  goto <D.20338>;
  <D.20337>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.21471 = i.23 * 4;
  D.21472 = appdomains_list.19 + D.21471;
  D.21473 = *D.21472;
  if (D.21473 == 0B) goto <D.21479>; else goto <D.21480>;
  <D.21479>:
  id = i;
  goto <D.20336>;
  <D.21480>:
  i = i + 1;
  <D.20338>:
  appdomain_next.22 = appdomain_next;
  D.21481 = (int) appdomain_next.22;
  if (D.21481 > i) goto <D.20337>; else goto <D.20336>;
  <D.20336>:
  <D.21478>:
  if (id == -1) goto <D.21482>; else goto <D.21483>;
  <D.21482>:
  {
    struct MonoDomain * * new_list;
    int new_size;

    appdomain_list_size.20 = appdomain_list_size;
    D.21476 = (int) appdomain_list_size.20;
    new_size = D.21476 * 2;
    if (new_size > 65535) goto <D.21484>; else goto <D.21485>;
    <D.21484>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1208);
    <D.21485>:
    appdomain_list_size.20 = appdomain_list_size;
    id = (int) appdomain_list_size.20;
    new_size.24 = (unsigned int) new_size;
    D.21487 = new_size.24 * 4;
    new_list = mono_gc_alloc_fixed (D.21487, 0B);
    appdomains_list.19 = appdomains_list;
    appdomain_list_size.20 = appdomain_list_size;
    D.21466 = (unsigned int) appdomain_list_size.20;
    D.21467 = D.21466 * 4;
    memcpy (new_list, appdomains_list.19, D.21467);
    appdomains_list.19 = appdomains_list;
    mono_gc_free_fixed (appdomains_list.19);
    appdomains_list = new_list;
    appdomain_list_size.25 = (short unsigned int) new_size;
    appdomain_list_size = appdomain_list_size.25;
  }
  <D.21483>:
  domain->domain_id = id;
  appdomains_list.19 = appdomains_list;
  id.26 = (unsigned int) id;
  D.21490 = id.26 * 4;
  D.21491 = appdomains_list.19 + D.21490;
  *D.21491 = domain;
  appdomain_next.22 = appdomain_next;
  appdomain_next.27 = appdomain_next.22;
  appdomain_next.28 = appdomain_next.27 + 1;
  appdomain_next = appdomain_next.28;
  appdomain_next.22 = appdomain_next;
  appdomain_list_size.20 = appdomain_list_size;
  if (appdomain_next.22 > appdomain_list_size.20) goto <D.21494>; else goto <D.21495>;
  <D.21494>:
  appdomain_next = 0;
  <D.21495>:
  D.21496 = id;
  return D.21496;
}


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

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


mono_init_internal (const char * filename, const char * exe_filename, const char * runtime_version)
{
  struct MonoDomain * domain.29;
  int D.21503;
  struct MonoDomain * domain.30;
  unsigned int appdomain_thread_id.31;
  const struct MonoRuntimeInfo * D.21513;
  const struct MonoRuntimeInfo * D.21514;
  const char[12] * D.21517;
  const struct MonoRuntimeInfo * current_runtime.32;
  const struct MonoRuntimeInfo * current_runtime.33;
  <unnamed type> status.34;
  const char * D.21526;
  const char[4] * D.21527;
  const char * D.21528;
  const char * D.21529;
  struct MonoImage * D.21531;
  struct MonoImage * D.21532;
  struct MonoClass * D.21533;
  struct MonoClass * D.21534;
  _Bool D.21535;
  long int D.21536;
  long int D.21537;
  struct MonoClass * D.21540;
  struct MonoClass * D.21541;
  _Bool D.21542;
  long int D.21543;
  long int D.21544;
  struct MonoClass * D.21547;
  struct MonoClass * D.21548;
  _Bool D.21549;
  long int D.21550;
  long int D.21551;
  struct MonoClass * D.21554;
  struct MonoClass * D.21555;
  _Bool D.21556;
  long int D.21557;
  long int D.21558;
  struct MonoClass * D.21561;
  struct MonoClass * D.21562;
  _Bool D.21563;
  long int D.21564;
  long int D.21565;
  struct MonoClass * D.21568;
  struct MonoClass * D.21569;
  _Bool D.21570;
  long int D.21571;
  long int D.21572;
  struct MonoClass * D.21575;
  struct MonoClass * D.21576;
  _Bool D.21577;
  long int D.21578;
  long int D.21579;
  struct MonoClass * D.21582;
  struct MonoClass * D.21583;
  _Bool D.21584;
  long int D.21585;
  long int D.21586;
  struct MonoClass * D.21589;
  struct MonoClass * D.21590;
  _Bool D.21591;
  long int D.21592;
  long int D.21593;
  struct MonoClass * D.21596;
  struct MonoClass * D.21597;
  _Bool D.21598;
  long int D.21599;
  long int D.21600;
  struct MonoClass * D.21603;
  struct MonoClass * D.21604;
  _Bool D.21605;
  long int D.21606;
  long int D.21607;
  struct MonoClass * D.21610;
  struct MonoClass * D.21611;
  _Bool D.21612;
  long int D.21613;
  long int D.21614;
  struct MonoClass * D.21617;
  struct MonoClass * D.21618;
  _Bool D.21619;
  long int D.21620;
  long int D.21621;
  struct MonoClass * D.21624;
  struct MonoClass * D.21625;
  _Bool D.21626;
  long int D.21627;
  long int D.21628;
  struct MonoClass * D.21631;
  struct MonoClass * D.21632;
  _Bool D.21633;
  long int D.21634;
  long int D.21635;
  struct MonoClass * D.21638;
  struct MonoClass * D.21639;
  _Bool D.21640;
  long int D.21641;
  long int D.21642;
  struct MonoClass * D.21645;
  struct MonoClass * D.21646;
  _Bool D.21647;
  long int D.21648;
  long int D.21649;
  struct MonoClass * D.21652;
  struct MonoClass * D.21653;
  _Bool D.21654;
  long int D.21655;
  long int D.21656;
  struct MonoClass * D.21659;
  struct MonoClass * D.21660;
  _Bool D.21661;
  long int D.21662;
  long int D.21663;
  struct MonoClass * D.21666;
  struct MonoClass * D.21667;
  _Bool D.21668;
  long int D.21669;
  long int D.21670;
  struct MonoClass * D.21673;
  struct MonoClass * D.21674;
  _Bool D.21675;
  long int D.21676;
  long int D.21677;
  struct MonoClass * D.21680;
  struct MonoClass * D.21681;
  _Bool D.21682;
  long int D.21683;
  long int D.21684;
  struct MonoClass * D.21687;
  struct MonoClass * D.21688;
  _Bool D.21689;
  long int D.21690;
  long int D.21691;
  struct MonoClass * D.21694;
  struct MonoClass * D.21695;
  _Bool D.21696;
  long int D.21697;
  long int D.21698;
  struct MonoClass * D.21701;
  struct MonoClass * D.21702;
  _Bool D.21703;
  long int D.21704;
  long int D.21705;
  struct MonoClass * D.21708;
  struct MonoClass * D.21709;
  _Bool D.21710;
  long int D.21711;
  long int D.21712;
  struct MonoClass * D.21715;
  struct MonoClass * D.21716;
  _Bool D.21717;
  long int D.21718;
  long int D.21719;
  struct MonoClass * D.21722;
  struct MonoClass * D.21723;
  _Bool D.21724;
  long int D.21725;
  long int D.21726;
  struct MonoClass * D.21729;
  struct MonoClass * D.21730;
  _Bool D.21731;
  long int D.21732;
  long int D.21733;
  struct MonoClass * D.21736;
  struct MonoClass * D.21737;
  _Bool D.21738;
  long int D.21739;
  long int D.21740;
  struct MonoClass * D.21743;
  struct MonoClass * D.21744;
  _Bool D.21745;
  long int D.21746;
  long int D.21747;
  struct MonoClass * D.21750;
  struct MonoClass * D.21751;
  struct _IO_FILE * stderr.35;
  const char * iftmp.36;
  struct MonoClass * D.21759;
  struct MonoClass * D.21760;
  _Bool D.21761;
  long int D.21762;
  long int D.21763;
  struct MonoClass * D.21766;
  struct MonoClass * D.21767;
  _Bool D.21768;
  long int D.21769;
  long int D.21770;
  struct MonoClass * D.21773;
  struct MonoClass * D.21774;
  _Bool D.21775;
  long int D.21776;
  long int D.21777;
  struct MonoClass * D.21780;
  struct MonoClass * D.21781;
  _Bool D.21782;
  long int D.21783;
  long int D.21784;
  struct MonoClass * D.21787;
  struct MonoClass * D.21788;
  _Bool D.21789;
  long int D.21790;
  long int D.21791;
  struct MonoClass * D.21794;
  struct MonoClass * D.21795;
  _Bool D.21796;
  long int D.21797;
  long int D.21798;
  struct MonoClass * D.21801;
  struct MonoClass * D.21802;
  _Bool D.21803;
  long int D.21804;
  long int D.21805;
  struct MonoClass * D.21808;
  struct MonoClass * D.21809;
  _Bool D.21810;
  long int D.21811;
  long int D.21812;
  struct MonoClass * D.21815;
  struct MonoClass * D.21816;
  _Bool D.21817;
  long int D.21818;
  long int D.21819;
  struct MonoClass * D.21822;
  struct MonoClass * D.21823;
  _Bool D.21824;
  long int D.21825;
  long int D.21826;
  struct MonoClass * D.21829;
  struct MonoClass * D.21830;
  _Bool D.21831;
  long int D.21832;
  long int D.21833;
  struct MonoClass * D.21836;
  struct MonoClass * D.21837;
  _Bool D.21838;
  long int D.21839;
  long int D.21840;
  struct MonoClass * D.21843;
  struct MonoClass * D.21844;
  _Bool D.21845;
  long int D.21846;
  long int D.21847;
  struct MonoClass * D.21850;
  struct MonoClass * D.21851;
  _Bool D.21852;
  long int D.21853;
  long int D.21854;
  struct MonoClass * D.21857;
  struct MonoClass * D.21858;
  _Bool D.21859;
  long int D.21860;
  long int D.21861;
  struct MonoClass * D.21864;
  struct MonoClass * D.21865;
  _Bool D.21866;
  long int D.21867;
  long int D.21868;
  struct MonoClass * D.21871;
  struct MonoClass * D.21872;
  struct MonoClass * D.21873;
  struct MonoClass * D.21874;
  struct MonoClass * D.21875;
  struct MonoClass * D.21876;
  struct MonoClass * D.21877;
  struct MonoClass * D.21878;
  struct MonoClass * D.21879;
  struct MonoClass * D.21880;
  struct MonoClass * D.21881;
  gchar * D.21882;
  struct MonoDomain * D.21883;
  static struct MonoDomain * domain = 0B;
  struct MonoAssembly * ass;
  MonoImageOpenStatus status;
  const struct MonoRuntimeInfo * runtimes[7];
  int n;

  try
    {
      ass = 0B;
      status = 0;
      domain.29 = domain;
      if (domain.29 != 0B) goto <D.21501>; else goto <D.21502>;
      <D.21501>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1334);
      <D.21502>:
      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.21503 = mono_gc_is_moving ();
      if (D.21503 == 0) goto <D.21504>; else goto <D.21505>;
      <D.21504>:
      mono_gc_register_root (&appdomains_list, 4, 0B);
      <D.21505>:
      domain.30 = mono_domain_create ();
      domain = domain.30;
      domain.29 = domain;
      mono_root_domain = domain.29;
      domain.29 = domain;
      tls_appdomain = domain.29;
      appdomain_thread_id.31 = appdomain_thread_id;
      domain.29 = domain;
      mono_native_tls_set_value (appdomain_thread_id.31, domain.29);
      domain.29 = domain;
      mono_gc_set_current_thread_appdomain (domain.29);
      if (exe_filename != 0B) goto <D.21508>; else goto <D.21509>;
      <D.21508>:
      get_runtimes_from_exe (exe_filename, &exe_image, &runtimes);
      goto <D.21510>;
      <D.21509>:
      if (runtime_version != 0B) goto <D.21511>; else goto <D.21512>;
      <D.21511>:
      D.21513 = get_runtime_by_version (runtime_version);
      runtimes[0] = D.21513;
      runtimes[1] = 0B;
      <D.21512>:
      <D.21510>:
      D.21514 = runtimes[0];
      if (D.21514 == 0B) goto <D.21515>; else goto <D.21516>;
      <D.21515>:
      {
        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.21517 = &default_runtime->runtime_version;
        monoeg_g_print ("Using default runtime: %s\n", D.21517);
      }
      <D.21516>:
      n = 0;
      goto <D.20371>;
      <D.20370>:
      current_runtime.32 = runtimes[n];
      current_runtime = current_runtime.32;
      current_runtime.33 = current_runtime;
      ass = mono_assembly_load_corlib (current_runtime.33, &status);
      status.34 = status;
      if (status.34 > 1) goto <D.20369>; else goto <D.21521>;
      <D.21521>:
      n = n + 1;
      <D.20371>:
      current_runtime.32 = runtimes[n];
      if (current_runtime.32 != 0B) goto <D.21522>; else goto <D.20369>;
      <D.21522>:
      if (ass == 0B) goto <D.20370>; else goto <D.20369>;
      <D.20369>:
      status.34 = status;
      if (status.34 != 0) goto <D.21523>; else goto <D.21525>;
      <D.21525>:
      if (ass == 0B) goto <D.21523>; else goto <D.21524>;
      <D.21523>:
      status.34 = status;
      switch (status.34) <default: <D.21530>, case 0: <D.20377>, case 1: <D.20372>, case 2: <D.20376>, case 3: <D.20375>>
      <D.20372>:
      {
        char * corlib_file;

        D.21526 = mono_assembly_getrootdir ();
        current_runtime.33 = current_runtime;
        D.21527 = &current_runtime.33->framework_version;
        corlib_file = monoeg_g_build_path ("/", D.21526, "mono", D.21527, "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.20374>;
      }
      <D.20375>:
      D.21528 = mono_assembly_getrootdir ();
      monoeg_g_print ("The file %s/mscorlib.dll is an invalid CIL image\n", D.21528);
      goto <D.20374>;
      <D.20376>:
      D.21529 = mono_assembly_getrootdir ();
      monoeg_g_print ("Missing assembly reference in %s/mscorlib.dll\n", D.21529);
      goto <D.20374>;
      <D.20377>:
      goto <D.20374>;
      <D.21530>:
      <D.20374>:
      exit (1);
      <D.21524>:
      D.21531 = mono_assembly_get_image (ass);
      mono_defaults.corlib = D.21531;
      D.21532 = mono_defaults.corlib;
      D.21533 = mono_class_from_name (D.21532, "System", "Object");
      mono_defaults.object_class = D.21533;
      D.21534 = mono_defaults.object_class;
      D.21535 = D.21534 == 0B;
      D.21536 = (long int) D.21535;
      D.21537 = __builtin_expect (D.21536, 0);
      if (D.21537 != 0) goto <D.21538>; else goto <D.21539>;
      <D.21538>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1442, "mono_defaults.object_class != 0");
      <D.21539>:
      D.21532 = mono_defaults.corlib;
      D.21540 = mono_class_from_name (D.21532, "System", "Void");
      mono_defaults.void_class = D.21540;
      D.21541 = mono_defaults.void_class;
      D.21542 = D.21541 == 0B;
      D.21543 = (long int) D.21542;
      D.21544 = __builtin_expect (D.21543, 0);
      if (D.21544 != 0) goto <D.21545>; else goto <D.21546>;
      <D.21545>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1446, "mono_defaults.void_class != 0");
      <D.21546>:
      D.21532 = mono_defaults.corlib;
      D.21547 = mono_class_from_name (D.21532, "System", "Boolean");
      mono_defaults.boolean_class = D.21547;
      D.21548 = mono_defaults.boolean_class;
      D.21549 = D.21548 == 0B;
      D.21550 = (long int) D.21549;
      D.21551 = __builtin_expect (D.21550, 0);
      if (D.21551 != 0) goto <D.21552>; else goto <D.21553>;
      <D.21552>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1450, "mono_defaults.boolean_class != 0");
      <D.21553>:
      D.21532 = mono_defaults.corlib;
      D.21554 = mono_class_from_name (D.21532, "System", "Byte");
      mono_defaults.byte_class = D.21554;
      D.21555 = mono_defaults.byte_class;
      D.21556 = D.21555 == 0B;
      D.21557 = (long int) D.21556;
      D.21558 = __builtin_expect (D.21557, 0);
      if (D.21558 != 0) goto <D.21559>; else goto <D.21560>;
      <D.21559>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1454, "mono_defaults.byte_class != 0");
      <D.21560>:
      D.21532 = mono_defaults.corlib;
      D.21561 = mono_class_from_name (D.21532, "System", "SByte");
      mono_defaults.sbyte_class = D.21561;
      D.21562 = mono_defaults.sbyte_class;
      D.21563 = D.21562 == 0B;
      D.21564 = (long int) D.21563;
      D.21565 = __builtin_expect (D.21564, 0);
      if (D.21565 != 0) goto <D.21566>; else goto <D.21567>;
      <D.21566>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1458, "mono_defaults.sbyte_class != 0");
      <D.21567>:
      D.21532 = mono_defaults.corlib;
      D.21568 = mono_class_from_name (D.21532, "System", "Int16");
      mono_defaults.int16_class = D.21568;
      D.21569 = mono_defaults.int16_class;
      D.21570 = D.21569 == 0B;
      D.21571 = (long int) D.21570;
      D.21572 = __builtin_expect (D.21571, 0);
      if (D.21572 != 0) goto <D.21573>; else goto <D.21574>;
      <D.21573>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1462, "mono_defaults.int16_class != 0");
      <D.21574>:
      D.21532 = mono_defaults.corlib;
      D.21575 = mono_class_from_name (D.21532, "System", "UInt16");
      mono_defaults.uint16_class = D.21575;
      D.21576 = mono_defaults.uint16_class;
      D.21577 = D.21576 == 0B;
      D.21578 = (long int) D.21577;
      D.21579 = __builtin_expect (D.21578, 0);
      if (D.21579 != 0) goto <D.21580>; else goto <D.21581>;
      <D.21580>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1466, "mono_defaults.uint16_class != 0");
      <D.21581>:
      D.21532 = mono_defaults.corlib;
      D.21582 = mono_class_from_name (D.21532, "System", "Int32");
      mono_defaults.int32_class = D.21582;
      D.21583 = mono_defaults.int32_class;
      D.21584 = D.21583 == 0B;
      D.21585 = (long int) D.21584;
      D.21586 = __builtin_expect (D.21585, 0);
      if (D.21586 != 0) goto <D.21587>; else goto <D.21588>;
      <D.21587>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1470, "mono_defaults.int32_class != 0");
      <D.21588>:
      D.21532 = mono_defaults.corlib;
      D.21589 = mono_class_from_name (D.21532, "System", "UInt32");
      mono_defaults.uint32_class = D.21589;
      D.21590 = mono_defaults.uint32_class;
      D.21591 = D.21590 == 0B;
      D.21592 = (long int) D.21591;
      D.21593 = __builtin_expect (D.21592, 0);
      if (D.21593 != 0) goto <D.21594>; else goto <D.21595>;
      <D.21594>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1474, "mono_defaults.uint32_class != 0");
      <D.21595>:
      D.21532 = mono_defaults.corlib;
      D.21596 = mono_class_from_name (D.21532, "System", "UIntPtr");
      mono_defaults.uint_class = D.21596;
      D.21597 = mono_defaults.uint_class;
      D.21598 = D.21597 == 0B;
      D.21599 = (long int) D.21598;
      D.21600 = __builtin_expect (D.21599, 0);
      if (D.21600 != 0) goto <D.21601>; else goto <D.21602>;
      <D.21601>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1478, "mono_defaults.uint_class != 0");
      <D.21602>:
      D.21532 = mono_defaults.corlib;
      D.21603 = mono_class_from_name (D.21532, "System", "IntPtr");
      mono_defaults.int_class = D.21603;
      D.21604 = mono_defaults.int_class;
      D.21605 = D.21604 == 0B;
      D.21606 = (long int) D.21605;
      D.21607 = __builtin_expect (D.21606, 0);
      if (D.21607 != 0) goto <D.21608>; else goto <D.21609>;
      <D.21608>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1482, "mono_defaults.int_class != 0");
      <D.21609>:
      D.21532 = mono_defaults.corlib;
      D.21610 = mono_class_from_name (D.21532, "System", "Int64");
      mono_defaults.int64_class = D.21610;
      D.21611 = mono_defaults.int64_class;
      D.21612 = D.21611 == 0B;
      D.21613 = (long int) D.21612;
      D.21614 = __builtin_expect (D.21613, 0);
      if (D.21614 != 0) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1486, "mono_defaults.int64_class != 0");
      <D.21616>:
      D.21532 = mono_defaults.corlib;
      D.21617 = mono_class_from_name (D.21532, "System", "UInt64");
      mono_defaults.uint64_class = D.21617;
      D.21618 = mono_defaults.uint64_class;
      D.21619 = D.21618 == 0B;
      D.21620 = (long int) D.21619;
      D.21621 = __builtin_expect (D.21620, 0);
      if (D.21621 != 0) goto <D.21622>; else goto <D.21623>;
      <D.21622>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1490, "mono_defaults.uint64_class != 0");
      <D.21623>:
      D.21532 = mono_defaults.corlib;
      D.21624 = mono_class_from_name (D.21532, "System", "Single");
      mono_defaults.single_class = D.21624;
      D.21625 = mono_defaults.single_class;
      D.21626 = D.21625 == 0B;
      D.21627 = (long int) D.21626;
      D.21628 = __builtin_expect (D.21627, 0);
      if (D.21628 != 0) goto <D.21629>; else goto <D.21630>;
      <D.21629>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1494, "mono_defaults.single_class != 0");
      <D.21630>:
      D.21532 = mono_defaults.corlib;
      D.21631 = mono_class_from_name (D.21532, "System", "Double");
      mono_defaults.double_class = D.21631;
      D.21632 = mono_defaults.double_class;
      D.21633 = D.21632 == 0B;
      D.21634 = (long int) D.21633;
      D.21635 = __builtin_expect (D.21634, 0);
      if (D.21635 != 0) goto <D.21636>; else goto <D.21637>;
      <D.21636>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1498, "mono_defaults.double_class != 0");
      <D.21637>:
      D.21532 = mono_defaults.corlib;
      D.21638 = mono_class_from_name (D.21532, "System", "Char");
      mono_defaults.char_class = D.21638;
      D.21639 = mono_defaults.char_class;
      D.21640 = D.21639 == 0B;
      D.21641 = (long int) D.21640;
      D.21642 = __builtin_expect (D.21641, 0);
      if (D.21642 != 0) goto <D.21643>; else goto <D.21644>;
      <D.21643>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1502, "mono_defaults.char_class != 0");
      <D.21644>:
      D.21532 = mono_defaults.corlib;
      D.21645 = mono_class_from_name (D.21532, "System", "String");
      mono_defaults.string_class = D.21645;
      D.21646 = mono_defaults.string_class;
      D.21647 = D.21646 == 0B;
      D.21648 = (long int) D.21647;
      D.21649 = __builtin_expect (D.21648, 0);
      if (D.21649 != 0) goto <D.21650>; else goto <D.21651>;
      <D.21650>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1506, "mono_defaults.string_class != 0");
      <D.21651>:
      D.21532 = mono_defaults.corlib;
      D.21652 = mono_class_from_name (D.21532, "System", "Enum");
      mono_defaults.enum_class = D.21652;
      D.21653 = mono_defaults.enum_class;
      D.21654 = D.21653 == 0B;
      D.21655 = (long int) D.21654;
      D.21656 = __builtin_expect (D.21655, 0);
      if (D.21656 != 0) goto <D.21657>; else goto <D.21658>;
      <D.21657>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1510, "mono_defaults.enum_class != 0");
      <D.21658>:
      D.21532 = mono_defaults.corlib;
      D.21659 = mono_class_from_name (D.21532, "System", "Array");
      mono_defaults.array_class = D.21659;
      D.21660 = mono_defaults.array_class;
      D.21661 = D.21660 == 0B;
      D.21662 = (long int) D.21661;
      D.21663 = __builtin_expect (D.21662, 0);
      if (D.21663 != 0) goto <D.21664>; else goto <D.21665>;
      <D.21664>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1514, "mono_defaults.array_class != 0");
      <D.21665>:
      D.21532 = mono_defaults.corlib;
      D.21666 = mono_class_from_name (D.21532, "System", "Delegate");
      mono_defaults.delegate_class = D.21666;
      D.21667 = mono_defaults.delegate_class;
      D.21668 = D.21667 == 0B;
      D.21669 = (long int) D.21668;
      D.21670 = __builtin_expect (D.21669, 0);
      if (D.21670 != 0) goto <D.21671>; else goto <D.21672>;
      <D.21671>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1518, "mono_defaults.delegate_class != 0");
      <D.21672>:
      D.21532 = mono_defaults.corlib;
      D.21673 = mono_class_from_name (D.21532, "System", "MulticastDelegate");
      mono_defaults.multicastdelegate_class = D.21673;
      D.21674 = mono_defaults.multicastdelegate_class;
      D.21675 = D.21674 == 0B;
      D.21676 = (long int) D.21675;
      D.21677 = __builtin_expect (D.21676, 0);
      if (D.21677 != 0) goto <D.21678>; else goto <D.21679>;
      <D.21678>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1522, "mono_defaults.multicastdelegate_class != 0");
      <D.21679>:
      D.21532 = mono_defaults.corlib;
      D.21680 = mono_class_from_name (D.21532, "System.Runtime.Remoting.Messaging", "AsyncResult");
      mono_defaults.asyncresult_class = D.21680;
      D.21681 = mono_defaults.asyncresult_class;
      D.21682 = D.21681 == 0B;
      D.21683 = (long int) D.21682;
      D.21684 = __builtin_expect (D.21683, 0);
      if (D.21684 != 0) goto <D.21685>; else goto <D.21686>;
      <D.21685>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1527, "mono_defaults.asyncresult_class != 0");
      <D.21686>:
      D.21532 = mono_defaults.corlib;
      D.21687 = mono_class_from_name (D.21532, "System.Threading", "ManualResetEvent");
      mono_defaults.manualresetevent_class = D.21687;
      D.21688 = mono_defaults.manualresetevent_class;
      D.21689 = D.21688 == 0B;
      D.21690 = (long int) D.21689;
      D.21691 = __builtin_expect (D.21690, 0);
      if (D.21691 != 0) goto <D.21692>; else goto <D.21693>;
      <D.21692>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1531, "mono_defaults.manualresetevent_class != 0");
      <D.21693>:
      D.21532 = mono_defaults.corlib;
      D.21694 = mono_class_from_name (D.21532, "System", "RuntimeTypeHandle");
      mono_defaults.typehandle_class = D.21694;
      D.21695 = mono_defaults.typehandle_class;
      D.21696 = D.21695 == 0B;
      D.21697 = (long int) D.21696;
      D.21698 = __builtin_expect (D.21697, 0);
      if (D.21698 != 0) goto <D.21699>; else goto <D.21700>;
      <D.21699>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1535, "mono_defaults.typehandle_class != 0");
      <D.21700>:
      D.21532 = mono_defaults.corlib;
      D.21701 = mono_class_from_name (D.21532, "System", "RuntimeMethodHandle");
      mono_defaults.methodhandle_class = D.21701;
      D.21702 = mono_defaults.methodhandle_class;
      D.21703 = D.21702 == 0B;
      D.21704 = (long int) D.21703;
      D.21705 = __builtin_expect (D.21704, 0);
      if (D.21705 != 0) goto <D.21706>; else goto <D.21707>;
      <D.21706>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1539, "mono_defaults.methodhandle_class != 0");
      <D.21707>:
      D.21532 = mono_defaults.corlib;
      D.21708 = mono_class_from_name (D.21532, "System", "RuntimeFieldHandle");
      mono_defaults.fieldhandle_class = D.21708;
      D.21709 = mono_defaults.fieldhandle_class;
      D.21710 = D.21709 == 0B;
      D.21711 = (long int) D.21710;
      D.21712 = __builtin_expect (D.21711, 0);
      if (D.21712 != 0) goto <D.21713>; else goto <D.21714>;
      <D.21713>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1543, "mono_defaults.fieldhandle_class != 0");
      <D.21714>:
      D.21532 = mono_defaults.corlib;
      D.21715 = mono_class_from_name (D.21532, "System", "Type");
      mono_defaults.systemtype_class = D.21715;
      D.21716 = mono_defaults.systemtype_class;
      D.21717 = D.21716 == 0B;
      D.21718 = (long int) D.21717;
      D.21719 = __builtin_expect (D.21718, 0);
      if (D.21719 != 0) goto <D.21720>; else goto <D.21721>;
      <D.21720>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1547, "mono_defaults.systemtype_class != 0");
      <D.21721>:
      D.21532 = mono_defaults.corlib;
      D.21722 = mono_class_from_name (D.21532, "System", "MonoType");
      mono_defaults.monotype_class = D.21722;
      D.21723 = mono_defaults.monotype_class;
      D.21724 = D.21723 == 0B;
      D.21725 = (long int) D.21724;
      D.21726 = __builtin_expect (D.21725, 0);
      if (D.21726 != 0) goto <D.21727>; else goto <D.21728>;
      <D.21727>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1551, "mono_defaults.monotype_class != 0");
      <D.21728>:
      D.21532 = mono_defaults.corlib;
      D.21729 = mono_class_from_name (D.21532, "System", "Exception");
      mono_defaults.exception_class = D.21729;
      D.21730 = mono_defaults.exception_class;
      D.21731 = D.21730 == 0B;
      D.21732 = (long int) D.21731;
      D.21733 = __builtin_expect (D.21732, 0);
      if (D.21733 != 0) goto <D.21734>; else goto <D.21735>;
      <D.21734>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1555, "mono_defaults.exception_class != 0");
      <D.21735>:
      D.21532 = mono_defaults.corlib;
      D.21736 = mono_class_from_name (D.21532, "System.Threading", "ThreadAbortException");
      mono_defaults.threadabortexception_class = D.21736;
      D.21737 = mono_defaults.threadabortexception_class;
      D.21738 = D.21737 == 0B;
      D.21739 = (long int) D.21738;
      D.21740 = __builtin_expect (D.21739, 0);
      if (D.21740 != 0) goto <D.21741>; else goto <D.21742>;
      <D.21741>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1559, "mono_defaults.threadabortexception_class != 0");
      <D.21742>:
      D.21532 = mono_defaults.corlib;
      D.21743 = mono_class_from_name (D.21532, "System.Threading", "Thread");
      mono_defaults.thread_class = D.21743;
      D.21744 = mono_defaults.thread_class;
      D.21745 = D.21744 == 0B;
      D.21746 = (long int) D.21745;
      D.21747 = __builtin_expect (D.21746, 0);
      if (D.21747 != 0) goto <D.21748>; else goto <D.21749>;
      <D.21748>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1563, "mono_defaults.thread_class != 0");
      <D.21749>:
      D.21532 = mono_defaults.corlib;
      D.21750 = mono_class_from_name (D.21532, "System.Threading", "InternalThread");
      mono_defaults.internal_thread_class = D.21750;
      D.21751 = mono_defaults.internal_thread_class;
      if (D.21751 == 0B) goto <D.21752>; else goto <D.21753>;
      <D.21752>:
      stderr.35 = stderr;
      fprintf (stderr.35, "Corlib too old for this runtime.\n");
      stderr.35 = stderr;
      D.21532 = mono_defaults.corlib;
      if (D.21532 != 0B) goto <D.21756>; else goto <D.21757>;
      <D.21756>:
      D.21532 = mono_defaults.corlib;
      iftmp.36 = mono_image_get_filename (D.21532);
      goto <D.21758>;
      <D.21757>:
      iftmp.36 = "unknown";
      <D.21758>:
      fprintf (stderr.35, "Loaded from: %s\n", iftmp.36);
      exit (1);
      <D.21753>:
      D.21532 = mono_defaults.corlib;
      D.21759 = mono_class_from_name (D.21532, "System", "AppDomain");
      mono_defaults.appdomain_class = D.21759;
      D.21760 = mono_defaults.appdomain_class;
      D.21761 = D.21760 == 0B;
      D.21762 = (long int) D.21761;
      D.21763 = __builtin_expect (D.21762, 0);
      if (D.21763 != 0) goto <D.21764>; else goto <D.21765>;
      <D.21764>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1577, "mono_defaults.appdomain_class != 0");
      <D.21765>:
      D.21532 = mono_defaults.corlib;
      D.21766 = mono_class_from_name (D.21532, "System.Runtime.Remoting.Proxies", "TransparentProxy");
      mono_defaults.transparent_proxy_class = D.21766;
      D.21767 = mono_defaults.transparent_proxy_class;
      D.21768 = D.21767 == 0B;
      D.21769 = (long int) D.21768;
      D.21770 = __builtin_expect (D.21769, 0);
      if (D.21770 != 0) goto <D.21771>; else goto <D.21772>;
      <D.21771>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1582, "mono_defaults.transparent_proxy_class != 0");
      <D.21772>:
      D.21532 = mono_defaults.corlib;
      D.21773 = mono_class_from_name (D.21532, "System.Runtime.Remoting.Proxies", "RealProxy");
      mono_defaults.real_proxy_class = D.21773;
      D.21774 = mono_defaults.real_proxy_class;
      D.21775 = D.21774 == 0B;
      D.21776 = (long int) D.21775;
      D.21777 = __builtin_expect (D.21776, 0);
      if (D.21777 != 0) goto <D.21778>; else goto <D.21779>;
      <D.21778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1586, "mono_defaults.real_proxy_class != 0");
      <D.21779>:
      D.21532 = mono_defaults.corlib;
      D.21780 = mono_class_from_name (D.21532, "System", "MarshalByRefObject");
      mono_defaults.marshalbyrefobject_class = D.21780;
      D.21781 = mono_defaults.marshalbyrefobject_class;
      D.21782 = D.21781 == 0B;
      D.21783 = (long int) D.21782;
      D.21784 = __builtin_expect (D.21783, 0);
      if (D.21784 != 0) goto <D.21785>; else goto <D.21786>;
      <D.21785>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1590, "mono_defaults.marshalbyrefobject_class != 0");
      <D.21786>:
      D.21532 = mono_defaults.corlib;
      D.21787 = mono_class_from_name (D.21532, "System.Runtime.Remoting", "IRemotingTypeInfo");
      mono_defaults.iremotingtypeinfo_class = D.21787;
      D.21788 = mono_defaults.iremotingtypeinfo_class;
      D.21789 = D.21788 == 0B;
      D.21790 = (long int) D.21789;
      D.21791 = __builtin_expect (D.21790, 0);
      if (D.21791 != 0) goto <D.21792>; else goto <D.21793>;
      <D.21792>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1594, "mono_defaults.iremotingtypeinfo_class != 0");
      <D.21793>:
      D.21532 = mono_defaults.corlib;
      D.21794 = mono_class_from_name (D.21532, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
      mono_defaults.mono_method_message_class = D.21794;
      D.21795 = mono_defaults.mono_method_message_class;
      D.21796 = D.21795 == 0B;
      D.21797 = (long int) D.21796;
      D.21798 = __builtin_expect (D.21797, 0);
      if (D.21798 != 0) goto <D.21799>; else goto <D.21800>;
      <D.21799>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1599, "mono_defaults.mono_method_message_class != 0");
      <D.21800>:
      D.21532 = mono_defaults.corlib;
      D.21801 = mono_class_from_name (D.21532, "System.Reflection", "FieldInfo");
      mono_defaults.field_info_class = D.21801;
      D.21802 = mono_defaults.field_info_class;
      D.21803 = D.21802 == 0B;
      D.21804 = (long int) D.21803;
      D.21805 = __builtin_expect (D.21804, 0);
      if (D.21805 != 0) goto <D.21806>; else goto <D.21807>;
      <D.21806>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1603, "mono_defaults.field_info_class != 0");
      <D.21807>:
      D.21532 = mono_defaults.corlib;
      D.21808 = mono_class_from_name (D.21532, "System.Reflection", "MethodInfo");
      mono_defaults.method_info_class = D.21808;
      D.21809 = mono_defaults.method_info_class;
      D.21810 = D.21809 == 0B;
      D.21811 = (long int) D.21810;
      D.21812 = __builtin_expect (D.21811, 0);
      if (D.21812 != 0) goto <D.21813>; else goto <D.21814>;
      <D.21813>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1607, "mono_defaults.method_info_class != 0");
      <D.21814>:
      D.21532 = mono_defaults.corlib;
      D.21815 = mono_class_from_name (D.21532, "System.Text", "StringBuilder");
      mono_defaults.stringbuilder_class = D.21815;
      D.21816 = mono_defaults.stringbuilder_class;
      D.21817 = D.21816 == 0B;
      D.21818 = (long int) D.21817;
      D.21819 = __builtin_expect (D.21818, 0);
      if (D.21819 != 0) goto <D.21820>; else goto <D.21821>;
      <D.21820>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1611, "mono_defaults.stringbuilder_class != 0");
      <D.21821>:
      D.21532 = mono_defaults.corlib;
      D.21822 = mono_class_from_name (D.21532, "System", "Math");
      mono_defaults.math_class = D.21822;
      D.21823 = mono_defaults.math_class;
      D.21824 = D.21823 == 0B;
      D.21825 = (long int) D.21824;
      D.21826 = __builtin_expect (D.21825, 0);
      if (D.21826 != 0) goto <D.21827>; else goto <D.21828>;
      <D.21827>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1615, "mono_defaults.math_class != 0");
      <D.21828>:
      D.21532 = mono_defaults.corlib;
      D.21829 = mono_class_from_name (D.21532, "System.Diagnostics", "StackFrame");
      mono_defaults.stack_frame_class = D.21829;
      D.21830 = mono_defaults.stack_frame_class;
      D.21831 = D.21830 == 0B;
      D.21832 = (long int) D.21831;
      D.21833 = __builtin_expect (D.21832, 0);
      if (D.21833 != 0) goto <D.21834>; else goto <D.21835>;
      <D.21834>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1619, "mono_defaults.stack_frame_class != 0");
      <D.21835>:
      D.21532 = mono_defaults.corlib;
      D.21836 = mono_class_from_name (D.21532, "System.Diagnostics", "StackTrace");
      mono_defaults.stack_trace_class = D.21836;
      D.21837 = mono_defaults.stack_trace_class;
      D.21838 = D.21837 == 0B;
      D.21839 = (long int) D.21838;
      D.21840 = __builtin_expect (D.21839, 0);
      if (D.21840 != 0) goto <D.21841>; else goto <D.21842>;
      <D.21841>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1623, "mono_defaults.stack_trace_class != 0");
      <D.21842>:
      D.21532 = mono_defaults.corlib;
      D.21843 = mono_class_from_name (D.21532, "System.Runtime.InteropServices", "Marshal");
      mono_defaults.marshal_class = D.21843;
      D.21844 = mono_defaults.marshal_class;
      D.21845 = D.21844 == 0B;
      D.21846 = (long int) D.21845;
      D.21847 = __builtin_expect (D.21846, 0);
      if (D.21847 != 0) goto <D.21848>; else goto <D.21849>;
      <D.21848>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1627, "mono_defaults.marshal_class != 0");
      <D.21849>:
      D.21532 = mono_defaults.corlib;
      D.21850 = mono_class_from_name (D.21532, "System", "TypedReference");
      mono_defaults.typed_reference_class = D.21850;
      D.21851 = mono_defaults.typed_reference_class;
      D.21852 = D.21851 == 0B;
      D.21853 = (long int) D.21852;
      D.21854 = __builtin_expect (D.21853, 0);
      if (D.21854 != 0) goto <D.21855>; else goto <D.21856>;
      <D.21855>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1631, "mono_defaults.typed_reference_class != 0");
      <D.21856>:
      D.21532 = mono_defaults.corlib;
      D.21857 = mono_class_from_name (D.21532, "System", "RuntimeArgumentHandle");
      mono_defaults.argumenthandle_class = D.21857;
      D.21858 = mono_defaults.argumenthandle_class;
      D.21859 = D.21858 == 0B;
      D.21860 = (long int) D.21859;
      D.21861 = __builtin_expect (D.21860, 0);
      if (D.21861 != 0) goto <D.21862>; else goto <D.21863>;
      <D.21862>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1635, "mono_defaults.argumenthandle_class != 0");
      <D.21863>:
      D.21532 = mono_defaults.corlib;
      D.21864 = mono_class_from_name (D.21532, "System.Threading", "Monitor");
      mono_defaults.monitor_class = D.21864;
      D.21865 = mono_defaults.monitor_class;
      D.21866 = D.21865 == 0B;
      D.21867 = (long int) D.21866;
      D.21868 = __builtin_expect (D.21867, 0);
      if (D.21868 != 0) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1639, "mono_defaults.monitor_class != 0");
      <D.21870>:
      D.21532 = mono_defaults.corlib;
      D.21871 = mono_class_from_name (D.21532, "System.Security", "RuntimeSecurityFrame");
      mono_defaults.runtimesecurityframe_class = D.21871;
      D.21532 = mono_defaults.corlib;
      D.21872 = mono_class_from_name (D.21532, "System.Threading", "ExecutionContext");
      mono_defaults.executioncontext_class = D.21872;
      D.21532 = mono_defaults.corlib;
      D.21873 = mono_class_from_name (D.21532, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute");
      mono_defaults.internals_visible_class = D.21873;
      D.21532 = mono_defaults.corlib;
      D.21874 = mono_class_from_name (D.21532, "System.Runtime.ConstrainedExecution", "CriticalFinalizerObject");
      mono_defaults.critical_finalizer_object = D.21874;
      mono_assembly_load_friends (ass);
      D.21532 = mono_defaults.corlib;
      D.21875 = mono_class_from_name (D.21532, "System.Runtime.InteropServices", "SafeHandle");
      mono_defaults.safehandle_class = D.21875;
      D.21532 = mono_defaults.corlib;
      D.21876 = mono_class_from_name (D.21532, "System.Runtime.InteropServices", "HandleRef");
      mono_defaults.handleref_class = D.21876;
      D.21532 = mono_defaults.corlib;
      D.21877 = mono_class_from_name (D.21532, "System", "Attribute");
      mono_defaults.attribute_class = D.21877;
      D.21532 = mono_defaults.corlib;
      D.21878 = mono_class_from_name (D.21532, "System.Reflection", "CustomAttributeData");
      mono_defaults.customattribute_data_class = D.21878;
      D.21660 = mono_defaults.array_class;
      mono_class_init (D.21660);
      D.21532 = mono_defaults.corlib;
      D.21879 = mono_class_from_name (D.21532, "System", "Nullable`1");
      mono_defaults.generic_nullable_class = D.21879;
      D.21532 = mono_defaults.corlib;
      D.21880 = mono_class_from_name (D.21532, "System.Collections.Generic", "IList`1");
      mono_defaults.generic_ilist_class = D.21880;
      D.21532 = mono_defaults.corlib;
      D.21881 = mono_class_from_name (D.21532, "System.Collections.Generic", "IReadOnlyList`1");
      mono_defaults.generic_ireadonlylist_class = D.21881;
      domain.29 = domain;
      D.21882 = monoeg_g_path_get_basename (filename);
      domain.29->friendly_name = D.21882;
      domain.29 = domain;
      _mono_debug_init_corlib (domain.29);
      D.21883 = domain;
      return D.21883;
    }
  finally
    {
      status = {CLOBBER};
      runtimes = {CLOBBER};
    }
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.21886;
  void (*<Tc1>) (void *) destructor.37;
  int D.21888;
  _Bool D.21889;

  destructor.37 = (void (*<Tc1>) (void *)) destructor;
  D.21888 = pthread_key_create (key, destructor.37);
  D.21889 = D.21888 == 0;
  D.21886 = (int) D.21889;
  return D.21886;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.21891;
  int D.21892;
  _Bool D.21893;

  D.21892 = pthread_setspecific (key, value);
  D.21893 = D.21892 == 0;
  D.21891 = (int) D.21893;
  return D.21891;
}


get_runtimes_from_exe (const char * exe_file, struct MonoImage * * exe_image, const struct MonoRuntimeInfo * * runtimes)
{
  struct GSList * D.21897;
  int n.38;
  unsigned int n.39;
  unsigned int D.21904;
  const struct MonoRuntimeInfo * * D.21905;
  struct GSList * iftmp.40;
  unsigned int n.41;
  unsigned int D.21911;
  const struct MonoRuntimeInfo * * D.21912;
  char * D.21913;
  const struct MonoRuntimeInfo * D.21916;
  const struct MonoRuntimeInfo * * D.21917;
  const struct MonoRuntimeInfo * D.21922;
  char * D.21923;
  const struct MonoRuntimeInfo * D.21924;
  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.21895>; else goto <D.21896>;
  <D.21895>:
  D.21897 = app_config->supported_runtimes;
  if (D.21897 != 0B) goto <D.21898>; else goto <D.21899>;
  <D.21898>:
  {
    int n;
    struct GSList * list;

    n = 0;
    list = app_config->supported_runtimes;
    goto <D.20783>;
    <D.20782>:
    version = list->data;
    runtime = get_runtime_by_version (version);
    if (runtime != 0B) goto <D.21900>; else goto <D.21901>;
    <D.21900>:
    n.38 = n;
    n = n.38 + 1;
    n.39 = (unsigned int) n.38;
    D.21904 = n.39 * 4;
    D.21905 = runtimes + D.21904;
    *D.21905 = runtime;
    <D.21901>:
    if (list != 0B) goto <D.21907>; else goto <D.21908>;
    <D.21907>:
    iftmp.40 = list->next;
    goto <D.21909>;
    <D.21908>:
    iftmp.40 = 0B;
    <D.21909>:
    list = iftmp.40;
    <D.20783>:
    if (list != 0B) goto <D.20782>; else goto <D.20784>;
    <D.20784>:
    n.41 = (unsigned int) n;
    D.21911 = n.41 * 4;
    D.21912 = runtimes + D.21911;
    *D.21912 = 0B;
    app_config_free (app_config);
    return;
  }
  <D.21899>:
  D.21913 = app_config->required_runtime;
  if (D.21913 != 0B) goto <D.21914>; else goto <D.21915>;
  <D.21914>:
  D.21913 = app_config->required_runtime;
  D.21916 = get_runtime_by_version (D.21913);
  *runtimes = D.21916;
  D.21917 = runtimes + 4;
  *D.21917 = 0B;
  app_config_free (app_config);
  return;
  <D.21915>:
  app_config_free (app_config);
  <D.21896>:
  image = mono_assembly_open_from_bundle (exe_file, 0B, 0);
  if (image == 0B) goto <D.21918>; else goto <D.21919>;
  <D.21918>:
  image = mono_image_open (exe_file, 0B);
  <D.21919>:
  if (image == 0B) goto <D.21920>; else goto <D.21921>;
  <D.21920>:
  D.21922 = get_runtime_by_version ("v2.0.50727");
  *runtimes = D.21922;
  D.21917 = runtimes + 4;
  *D.21917 = 0B;
  return;
  <D.21921>:
  *exe_image = image;
  D.21923 = image->version;
  D.21924 = get_runtime_by_version (D.21923);
  *runtimes = D.21924;
  D.21917 = runtimes + 4;
  *D.21917 = 0B;
}


app_config_parse (const char * exe_filename)
{
  gchar * text.42;
  char * text.43;
  unsigned int len.44;
  int D.21932;
  struct AppConfigInfo * D.21935;
  unsigned int len.45;
  int len.46;
  int D.21938;
  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.21926>; else goto <D.21927>;
      <D.21926>:
      text.42 = monoeg_strdup (bundled_config);
      text = text.42;
      text.43 = text;
      len.44 = strlen (text.43);
      len = len.44;
      goto <D.21931>;
      <D.21927>:
      config_filename = monoeg_g_strconcat (exe_filename, ".config", 0B);
      D.21932 = monoeg_g_file_get_contents (config_filename, &text, &len, 0B);
      if (D.21932 == 0) goto <D.21933>; else goto <D.21934>;
      <D.21933>:
      monoeg_g_free (config_filename);
      D.21935 = 0B;
      return D.21935;
      <D.21934>:
      monoeg_g_free (config_filename);
      <D.21931>:
      app_config = monoeg_malloc0 (16);
      context = monoeg_g_markup_parse_context_new (&mono_parser, 0, app_config, 0B);
      text.43 = text;
      len.45 = len;
      len.46 = (int) len.45;
      D.21938 = monoeg_g_markup_parse_context_parse (context, text.43, len.46, 0B);
      if (D.21938 != 0) goto <D.21939>; else goto <D.21940>;
      <D.21939>:
      monoeg_g_markup_parse_context_end_parse (context, 0B);
      <D.21940>:
      monoeg_g_markup_parse_context_free (context);
      text.43 = text;
      monoeg_g_free (text.43);
      D.21935 = app_config;
      return D.21935;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  int D.20713;
  int iftmp.47;
  int D.20712;
  const char[14] * D.21946;
  unsigned char D.21947;
  int D.21948;
  unsigned char D.21949;
  int D.21950;
  _Bool D.21951;
  _Bool D.21952;
  _Bool D.21953;
  const unsigned char * D.21956;
  unsigned char D.21957;
  int D.21958;
  const unsigned char * D.21959;
  unsigned char D.21960;
  int D.21961;
  _Bool D.21962;
  _Bool D.21963;
  const unsigned char * D.21966;
  unsigned char D.21967;
  int D.21968;
  const unsigned char * D.21969;
  unsigned char D.21970;
  int D.21971;
  _Bool D.21972;
  _Bool D.21973;
  const unsigned char * D.21976;
  unsigned char D.21977;
  int D.21978;
  const unsigned char * D.21979;
  unsigned char D.21980;
  int D.21981;
  int D.21985;
  int D.21986;
  int D.20722;
  int iftmp.48;
  int D.20721;
  const char[8] * D.21991;
  unsigned char D.21992;
  int D.21993;
  unsigned char D.21994;
  int D.21995;
  _Bool D.21996;
  _Bool D.21997;
  _Bool D.21998;
  const unsigned char * D.22001;
  unsigned char D.22002;
  int D.22003;
  const unsigned char * D.22004;
  unsigned char D.22005;
  int D.22006;
  _Bool D.22007;
  _Bool D.22008;
  const unsigned char * D.22011;
  unsigned char D.22012;
  int D.22013;
  const unsigned char * D.22014;
  unsigned char D.22015;
  int D.22016;
  _Bool D.22017;
  _Bool D.22018;
  const unsigned char * D.22021;
  unsigned char D.22022;
  int D.22023;
  const unsigned char * D.22024;
  unsigned char D.22025;
  int D.22026;
  int D.22030;
  int D.22031;
  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.21944>; else goto <D.21945>;
    <D.21944>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.21946 = "configuration";
      D.21947 = MEM[(const unsigned char *)D.21946];
      D.21948 = (int) D.21947;
      D.21949 = *__s2;
      D.21950 = (int) D.21949;
      __result = D.21948 - D.21950;
      {
        D.21951 = __s2_len != 0;
        D.21952 = __result == 0;
        D.21953 = D.21951 & D.21952;
        if (D.21953 != 0) goto <D.21954>; else goto <D.21955>;
        <D.21954>:
        D.21956 = &MEM[(void *)"configuration" + 1B];
        D.21957 = *D.21956;
        D.21958 = (int) D.21957;
        D.21959 = __s2 + 1;
        D.21960 = *D.21959;
        D.21961 = (int) D.21960;
        __result = D.21958 - D.21961;
        D.21962 = __s2_len > 1;
        D.21952 = __result == 0;
        D.21963 = D.21962 & D.21952;
        if (D.21963 != 0) goto <D.21964>; else goto <D.21965>;
        <D.21964>:
        D.21966 = &MEM[(void *)"configuration" + 2B];
        D.21967 = *D.21966;
        D.21968 = (int) D.21967;
        D.21969 = __s2 + 2;
        D.21970 = *D.21969;
        D.21971 = (int) D.21970;
        __result = D.21968 - D.21971;
        D.21972 = __s2_len > 2;
        D.21952 = __result == 0;
        D.21973 = D.21972 & D.21952;
        if (D.21973 != 0) goto <D.21974>; else goto <D.21975>;
        <D.21974>:
        D.21976 = &MEM[(void *)"configuration" + 3B];
        D.21977 = *D.21976;
        D.21978 = (int) D.21977;
        D.21979 = __s2 + 3;
        D.21980 = *D.21979;
        D.21981 = (int) D.21980;
        __result = D.21978 - D.21981;
        <D.21975>:
        <D.21965>:
        <D.21955>:
      }
      D.20712 = __result;
    }
    iftmp.47 = -D.20712;
    goto <D.21982>;
    <D.21945>:
    iftmp.47 = __builtin_strcmp (element_name, "configuration");
    <D.21982>:
    D.20713 = iftmp.47;
  }
  if (D.20713 == 0) goto <D.21983>; else goto <D.21984>;
  <D.21983>:
  D.21985 = app_config->configuration_count;
  D.21986 = D.21985 + -1;
  app_config->configuration_count = D.21986;
  goto <D.21987>;
  <D.21984>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.21991 = "startup";
      D.21992 = MEM[(const unsigned char *)D.21991];
      D.21993 = (int) D.21992;
      D.21994 = *__s2;
      D.21995 = (int) D.21994;
      __result = D.21993 - D.21995;
      {
        D.21996 = __s2_len != 0;
        D.21997 = __result == 0;
        D.21998 = D.21996 & D.21997;
        if (D.21998 != 0) goto <D.21999>; else goto <D.22000>;
        <D.21999>:
        D.22001 = &MEM[(void *)"startup" + 1B];
        D.22002 = *D.22001;
        D.22003 = (int) D.22002;
        D.22004 = __s2 + 1;
        D.22005 = *D.22004;
        D.22006 = (int) D.22005;
        __result = D.22003 - D.22006;
        D.22007 = __s2_len > 1;
        D.21997 = __result == 0;
        D.22008 = D.22007 & D.21997;
        if (D.22008 != 0) goto <D.22009>; else goto <D.22010>;
        <D.22009>:
        D.22011 = &MEM[(void *)"startup" + 2B];
        D.22012 = *D.22011;
        D.22013 = (int) D.22012;
        D.22014 = __s2 + 2;
        D.22015 = *D.22014;
        D.22016 = (int) D.22015;
        __result = D.22013 - D.22016;
        D.22017 = __s2_len > 2;
        D.21997 = __result == 0;
        D.22018 = D.22017 & D.21997;
        if (D.22018 != 0) goto <D.22019>; else goto <D.22020>;
        <D.22019>:
        D.22021 = &MEM[(void *)"startup" + 3B];
        D.22022 = *D.22021;
        D.22023 = (int) D.22022;
        D.22024 = __s2 + 3;
        D.22025 = *D.22024;
        D.22026 = (int) D.22025;
        __result = D.22023 - D.22026;
        <D.22020>:
        <D.22010>:
        <D.22000>:
      }
      D.20721 = __result;
    }
    iftmp.48 = -D.20721;
    goto <D.22027>;
    <D.21990>:
    iftmp.48 = __builtin_strcmp (element_name, "startup");
    <D.22027>:
    D.20722 = iftmp.48;
  }
  if (D.20722 == 0) goto <D.22028>; else goto <D.22029>;
  <D.22028>:
  D.22030 = app_config->startup_count;
  D.22031 = D.22030 + -1;
  app_config->startup_count = D.22031;
  <D.22029>:
  <D.21987>:
}


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.20669;
  int iftmp.49;
  int D.20668;
  const char[14] * D.22035;
  unsigned char D.22036;
  int D.22037;
  unsigned char D.22038;
  int D.22039;
  _Bool D.22040;
  _Bool D.22041;
  _Bool D.22042;
  const unsigned char * D.22045;
  unsigned char D.22046;
  int D.22047;
  const unsigned char * D.22048;
  unsigned char D.22049;
  int D.22050;
  _Bool D.22051;
  _Bool D.22052;
  const unsigned char * D.22055;
  unsigned char D.22056;
  int D.22057;
  const unsigned char * D.22058;
  unsigned char D.22059;
  int D.22060;
  _Bool D.22061;
  _Bool D.22062;
  const unsigned char * D.22065;
  unsigned char D.22066;
  int D.22067;
  const unsigned char * D.22068;
  unsigned char D.22069;
  int D.22070;
  int D.22074;
  int D.22075;
  int D.20678;
  int iftmp.50;
  int D.20677;
  const char[8] * D.22079;
  unsigned char D.22080;
  int D.22081;
  unsigned char D.22082;
  int D.22083;
  _Bool D.22084;
  _Bool D.22085;
  _Bool D.22086;
  const unsigned char * D.22089;
  unsigned char D.22090;
  int D.22091;
  const unsigned char * D.22092;
  unsigned char D.22093;
  int D.22094;
  _Bool D.22095;
  _Bool D.22096;
  const unsigned char * D.22099;
  unsigned char D.22100;
  int D.22101;
  const unsigned char * D.22102;
  unsigned char D.22103;
  int D.22104;
  _Bool D.22105;
  _Bool D.22106;
  const unsigned char * D.22109;
  unsigned char D.22110;
  int D.22111;
  const unsigned char * D.22112;
  unsigned char D.22113;
  int D.22114;
  int D.22118;
  int D.22119;
  int D.20687;
  int iftmp.51;
  int D.20686;
  const char[16] * D.22126;
  unsigned char D.22127;
  int D.22128;
  unsigned char D.22129;
  int D.22130;
  _Bool D.22131;
  _Bool D.22132;
  _Bool D.22133;
  const unsigned char * D.22136;
  unsigned char D.22137;
  int D.22138;
  const unsigned char * D.22139;
  unsigned char D.22140;
  int D.22141;
  _Bool D.22142;
  _Bool D.22143;
  const unsigned char * D.22146;
  unsigned char D.22147;
  int D.22148;
  const unsigned char * D.22149;
  unsigned char D.22150;
  int D.22151;
  _Bool D.22152;
  _Bool D.22153;
  const unsigned char * D.22156;
  unsigned char D.22157;
  int D.22158;
  const unsigned char * D.22159;
  unsigned char D.22160;
  int D.22161;
  char * D.22165;
  int D.20696;
  int iftmp.52;
  int D.20695;
  const char[17] * D.22170;
  unsigned char D.22171;
  int D.22172;
  unsigned char D.22173;
  int D.22174;
  _Bool D.22175;
  _Bool D.22176;
  _Bool D.22177;
  const unsigned char * D.22180;
  unsigned char D.22181;
  int D.22182;
  const unsigned char * D.22183;
  unsigned char D.22184;
  int D.22185;
  _Bool D.22186;
  _Bool D.22187;
  const unsigned char * D.22190;
  unsigned char D.22191;
  int D.22192;
  const unsigned char * D.22193;
  unsigned char D.22194;
  int D.22195;
  _Bool D.22196;
  _Bool D.22197;
  const unsigned char * D.22200;
  unsigned char D.22201;
  int D.22202;
  const unsigned char * D.22203;
  unsigned char D.22204;
  int D.22205;
  struct GSList * D.22209;
  struct GSList * D.22210;
  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.22033>; else goto <D.22034>;
    <D.22033>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.22035 = "configuration";
      D.22036 = MEM[(const unsigned char *)D.22035];
      D.22037 = (int) D.22036;
      D.22038 = *__s2;
      D.22039 = (int) D.22038;
      __result = D.22037 - D.22039;
      {
        D.22040 = __s2_len != 0;
        D.22041 = __result == 0;
        D.22042 = D.22040 & D.22041;
        if (D.22042 != 0) goto <D.22043>; else goto <D.22044>;
        <D.22043>:
        D.22045 = &MEM[(void *)"configuration" + 1B];
        D.22046 = *D.22045;
        D.22047 = (int) D.22046;
        D.22048 = __s2 + 1;
        D.22049 = *D.22048;
        D.22050 = (int) D.22049;
        __result = D.22047 - D.22050;
        D.22051 = __s2_len > 1;
        D.22041 = __result == 0;
        D.22052 = D.22051 & D.22041;
        if (D.22052 != 0) goto <D.22053>; else goto <D.22054>;
        <D.22053>:
        D.22055 = &MEM[(void *)"configuration" + 2B];
        D.22056 = *D.22055;
        D.22057 = (int) D.22056;
        D.22058 = __s2 + 2;
        D.22059 = *D.22058;
        D.22060 = (int) D.22059;
        __result = D.22057 - D.22060;
        D.22061 = __s2_len > 2;
        D.22041 = __result == 0;
        D.22062 = D.22061 & D.22041;
        if (D.22062 != 0) goto <D.22063>; else goto <D.22064>;
        <D.22063>:
        D.22065 = &MEM[(void *)"configuration" + 3B];
        D.22066 = *D.22065;
        D.22067 = (int) D.22066;
        D.22068 = __s2 + 3;
        D.22069 = *D.22068;
        D.22070 = (int) D.22069;
        __result = D.22067 - D.22070;
        <D.22064>:
        <D.22054>:
        <D.22044>:
      }
      D.20668 = __result;
    }
    iftmp.49 = -D.20668;
    goto <D.22071>;
    <D.22034>:
    iftmp.49 = __builtin_strcmp (element_name, "configuration");
    <D.22071>:
    D.20669 = iftmp.49;
  }
  if (D.20669 == 0) goto <D.22072>; else goto <D.22073>;
  <D.22072>:
  D.22074 = app_config->configuration_count;
  D.22075 = D.22074 + 1;
  app_config->configuration_count = D.22075;
  return;
  <D.22073>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.22079 = "startup";
      D.22080 = MEM[(const unsigned char *)D.22079];
      D.22081 = (int) D.22080;
      D.22082 = *__s2;
      D.22083 = (int) D.22082;
      __result = D.22081 - D.22083;
      {
        D.22084 = __s2_len != 0;
        D.22085 = __result == 0;
        D.22086 = D.22084 & D.22085;
        if (D.22086 != 0) goto <D.22087>; else goto <D.22088>;
        <D.22087>:
        D.22089 = &MEM[(void *)"startup" + 1B];
        D.22090 = *D.22089;
        D.22091 = (int) D.22090;
        D.22092 = __s2 + 1;
        D.22093 = *D.22092;
        D.22094 = (int) D.22093;
        __result = D.22091 - D.22094;
        D.22095 = __s2_len > 1;
        D.22085 = __result == 0;
        D.22096 = D.22095 & D.22085;
        if (D.22096 != 0) goto <D.22097>; else goto <D.22098>;
        <D.22097>:
        D.22099 = &MEM[(void *)"startup" + 2B];
        D.22100 = *D.22099;
        D.22101 = (int) D.22100;
        D.22102 = __s2 + 2;
        D.22103 = *D.22102;
        D.22104 = (int) D.22103;
        __result = D.22101 - D.22104;
        D.22105 = __s2_len > 2;
        D.22085 = __result == 0;
        D.22106 = D.22105 & D.22085;
        if (D.22106 != 0) goto <D.22107>; else goto <D.22108>;
        <D.22107>:
        D.22109 = &MEM[(void *)"startup" + 3B];
        D.22110 = *D.22109;
        D.22111 = (int) D.22110;
        D.22112 = __s2 + 3;
        D.22113 = *D.22112;
        D.22114 = (int) D.22113;
        __result = D.22111 - D.22114;
        <D.22108>:
        <D.22098>:
        <D.22088>:
      }
      D.20677 = __result;
    }
    iftmp.50 = -D.20677;
    goto <D.22115>;
    <D.22078>:
    iftmp.50 = __builtin_strcmp (element_name, "startup");
    <D.22115>:
    D.20678 = iftmp.50;
  }
  if (D.20678 == 0) goto <D.22116>; else goto <D.22117>;
  <D.22116>:
  D.22118 = app_config->startup_count;
  D.22119 = D.22118 + 1;
  app_config->startup_count = D.22119;
  return;
  <D.22117>:
  D.22074 = app_config->configuration_count;
  if (D.22074 != 1) goto <D.22120>; else goto <D.22122>;
  <D.22122>:
  D.22118 = app_config->startup_count;
  if (D.22118 != 1) goto <D.22120>; else goto <D.22121>;
  <D.22120>:
  return;
  <D.22121>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.22126 = "requiredRuntime";
      D.22127 = MEM[(const unsigned char *)D.22126];
      D.22128 = (int) D.22127;
      D.22129 = *__s2;
      D.22130 = (int) D.22129;
      __result = D.22128 - D.22130;
      {
        D.22131 = __s2_len != 0;
        D.22132 = __result == 0;
        D.22133 = D.22131 & D.22132;
        if (D.22133 != 0) goto <D.22134>; else goto <D.22135>;
        <D.22134>:
        D.22136 = &MEM[(void *)"requiredRuntime" + 1B];
        D.22137 = *D.22136;
        D.22138 = (int) D.22137;
        D.22139 = __s2 + 1;
        D.22140 = *D.22139;
        D.22141 = (int) D.22140;
        __result = D.22138 - D.22141;
        D.22142 = __s2_len > 1;
        D.22132 = __result == 0;
        D.22143 = D.22142 & D.22132;
        if (D.22143 != 0) goto <D.22144>; else goto <D.22145>;
        <D.22144>:
        D.22146 = &MEM[(void *)"requiredRuntime" + 2B];
        D.22147 = *D.22146;
        D.22148 = (int) D.22147;
        D.22149 = __s2 + 2;
        D.22150 = *D.22149;
        D.22151 = (int) D.22150;
        __result = D.22148 - D.22151;
        D.22152 = __s2_len > 2;
        D.22132 = __result == 0;
        D.22153 = D.22152 & D.22132;
        if (D.22153 != 0) goto <D.22154>; else goto <D.22155>;
        <D.22154>:
        D.22156 = &MEM[(void *)"requiredRuntime" + 3B];
        D.22157 = *D.22156;
        D.22158 = (int) D.22157;
        D.22159 = __s2 + 3;
        D.22160 = *D.22159;
        D.22161 = (int) D.22160;
        __result = D.22158 - D.22161;
        <D.22155>:
        <D.22145>:
        <D.22135>:
      }
      D.20686 = __result;
    }
    iftmp.51 = -D.20686;
    goto <D.22162>;
    <D.22125>:
    iftmp.51 = __builtin_strcmp (element_name, "requiredRuntime");
    <D.22162>:
    D.20687 = iftmp.51;
  }
  if (D.20687 == 0) goto <D.22163>; else goto <D.22164>;
  <D.22163>:
  D.22165 = get_attribute_value (attribute_names, attribute_values, "version");
  app_config->required_runtime = D.22165;
  goto <D.22166>;
  <D.22164>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.22170 = "supportedRuntime";
      D.22171 = MEM[(const unsigned char *)D.22170];
      D.22172 = (int) D.22171;
      D.22173 = *__s2;
      D.22174 = (int) D.22173;
      __result = D.22172 - D.22174;
      {
        D.22175 = __s2_len != 0;
        D.22176 = __result == 0;
        D.22177 = D.22175 & D.22176;
        if (D.22177 != 0) goto <D.22178>; else goto <D.22179>;
        <D.22178>:
        D.22180 = &MEM[(void *)"supportedRuntime" + 1B];
        D.22181 = *D.22180;
        D.22182 = (int) D.22181;
        D.22183 = __s2 + 1;
        D.22184 = *D.22183;
        D.22185 = (int) D.22184;
        __result = D.22182 - D.22185;
        D.22186 = __s2_len > 1;
        D.22176 = __result == 0;
        D.22187 = D.22186 & D.22176;
        if (D.22187 != 0) goto <D.22188>; else goto <D.22189>;
        <D.22188>:
        D.22190 = &MEM[(void *)"supportedRuntime" + 2B];
        D.22191 = *D.22190;
        D.22192 = (int) D.22191;
        D.22193 = __s2 + 2;
        D.22194 = *D.22193;
        D.22195 = (int) D.22194;
        __result = D.22192 - D.22195;
        D.22196 = __s2_len > 2;
        D.22176 = __result == 0;
        D.22197 = D.22196 & D.22176;
        if (D.22197 != 0) goto <D.22198>; else goto <D.22199>;
        <D.22198>:
        D.22200 = &MEM[(void *)"supportedRuntime" + 3B];
        D.22201 = *D.22200;
        D.22202 = (int) D.22201;
        D.22203 = __s2 + 3;
        D.22204 = *D.22203;
        D.22205 = (int) D.22204;
        __result = D.22202 - D.22205;
        <D.22199>:
        <D.22189>:
        <D.22179>:
      }
      D.20695 = __result;
    }
    iftmp.52 = -D.20695;
    goto <D.22206>;
    <D.22169>:
    iftmp.52 = __builtin_strcmp (element_name, "supportedRuntime");
    <D.22206>:
    D.20696 = iftmp.52;
  }
  if (D.20696 == 0) goto <D.22207>; else goto <D.22208>;
  <D.22207>:
  {
    char * version;

    version = get_attribute_value (attribute_names, attribute_values, "version");
    D.22209 = app_config->supported_runtimes;
    D.22210 = monoeg_g_slist_append (D.22209, version);
    app_config->supported_runtimes = D.22210;
  }
  <D.22208>:
  <D.22166>:
}


get_attribute_value (const gchar * * attribute_names, const gchar * * attribute_values, const char * att_name)
{
  int D.20648;
  unsigned int n.53;
  unsigned int D.22213;
  const gchar * * D.22214;
  const gchar * D.22215;
  char * D.22218;
  const gchar * * D.22219;
  const gchar * D.22220;
  int n;

  n = 0;
  goto <D.20650>;
  <D.20649>:
  {
    size_t __s1_len;
    size_t __s2_len;

    n.53 = (unsigned int) n;
    D.22213 = n.53 * 4;
    D.22214 = attribute_names + D.22213;
    D.22215 = *D.22214;
    D.20648 = __builtin_strcmp (D.22215, att_name);
  }
  if (D.20648 == 0) goto <D.22216>; else goto <D.22217>;
  <D.22216>:
  n.53 = (unsigned int) n;
  D.22213 = n.53 * 4;
  D.22219 = attribute_values + D.22213;
  D.22220 = *D.22219;
  D.22218 = monoeg_strdup (D.22220);
  return D.22218;
  <D.22217>:
  n = n + 1;
  <D.20650>:
  n.53 = (unsigned int) n;
  D.22213 = n.53 * 4;
  D.22214 = attribute_names + D.22213;
  D.22215 = *D.22214;
  if (D.22215 != 0B) goto <D.20649>; else goto <D.20651>;
  <D.20651>:
  D.22218 = 0B;
  return D.22218;
}


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

  if (str != 0B) goto <D.22222>; else goto <D.22223>;
  <D.22222>:
  D.22224 = __strdup (str);
  return D.22224;
  <D.22223>:
  D.22224 = 0B;
  return D.22224;
}


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

  list = app_config->supported_runtimes;
  goto <D.20739>;
  <D.20738>:
  rt = list->data;
  monoeg_g_free (rt);
  if (list != 0B) goto <D.22227>; else goto <D.22228>;
  <D.22227>:
  iftmp.54 = list->next;
  goto <D.22229>;
  <D.22228>:
  iftmp.54 = 0B;
  <D.22229>:
  list = iftmp.54;
  <D.20739>:
  if (list != 0B) goto <D.20738>; else goto <D.20740>;
  <D.20740>:
  D.22230 = app_config->supported_runtimes;
  monoeg_g_slist_free (D.22230);
  D.22231 = app_config->required_runtime;
  monoeg_g_free (D.22231);
  monoeg_g_free (app_config);
}


get_runtime_by_version (const char * version)
{
  const struct MonoRuntimeInfo * D.22234;
  int D.20755;
  const char[12] * D.22235;
  unsigned int D.22238;
  const char * D.22241;
  char D.22242;
  int D.22243;
  int D.22246;
  int n;
  int max;
  int vlen;

  max = 6;
  if (version == 0B) goto <D.22232>; else goto <D.22233>;
  <D.22232>:
  D.22234 = 0B;
  return D.22234;
  <D.22233>:
  n = 0;
  goto <D.20757>;
  <D.20756>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22235 = &supported_runtimes[n].runtime_version;
    D.20755 = __builtin_strcmp (version, D.22235);
  }
  if (D.20755 == 0) goto <D.22236>; else goto <D.22237>;
  <D.22236>:
  D.22234 = &supported_runtimes[n];
  return D.22234;
  <D.22237>:
  n = n + 1;
  <D.20757>:
  if (n < max) goto <D.20756>; else goto <D.20758>;
  <D.20758>:
  D.22238 = strlen (version);
  vlen = (int) D.22238;
  if (vlen > 3) goto <D.22239>; else goto <D.22240>;
  <D.22239>:
  D.22241 = version + 1;
  D.22242 = *D.22241;
  D.22243 = (int) D.22242;
  if (D.22243 > 51) goto <D.22244>; else goto <D.22245>;
  <D.22244>:
  n = 0;
  goto <D.20769>;
  <D.20768>:
  D.22235 = &supported_runtimes[n].runtime_version;
  D.22246 = strncmp (version, D.22235, 4);
  if (D.22246 == 0) goto <D.22247>; else goto <D.22248>;
  <D.22247>:
  D.22234 = &supported_runtimes[n];
  return D.22234;
  <D.22248>:
  n = n + 1;
  <D.20769>:
  if (n < max) goto <D.20768>; else goto <D.20770>;
  <D.20770>:
  <D.22245>:
  <D.22240>:
  D.22234 = 0B;
  return D.22234;
}


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

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


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

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


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

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


mono_cleanup ()
{
  unsigned int appdomain_thread_id.55;

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


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


mono_close_exe_image ()
{
  struct MonoImage * exe_image.56;

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


mono_get_root_domain ()
{
  struct MonoDomain * D.22260;

  D.22260 = mono_root_domain;
  return D.22260;
}


mono_domain_get ()
{
  struct MonoDomain * D.22262;

  D.22262 = tls_appdomain;
  return D.22262;
}


mono_domain_unset ()
{
  unsigned int appdomain_thread_id.57;

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


mono_domain_set_internal_with_options (struct MonoDomain * domain, gboolean migrate_exception)
{
  struct MonoDomain * D.22265;
  unsigned int appdomain_thread_id.58;
  struct MonoInternalThread * D.22269;
  struct MonoInternalThread * D.22270;
  struct MonoAppContext * * D.22271;
  struct MonoAppContext * D.22272;
  struct MonoException * D.22275;
  struct MonoVTable * D.22278;
  struct MonoDomain * D.22279;
  _Bool D.22280;
  long int D.22281;
  long int D.22282;
  struct MonoException * * D.22285;
  struct MonoException * D.22286;
  _Bool D.22287;
  long int D.22288;
  long int D.22289;
  struct MonoInternalThread * thread;

  D.22265 = mono_domain_get ();
  if (D.22265 == domain) goto <D.22266>; else goto <D.22267>;
  <D.22266>:
  return;
  <D.22267>:
  tls_appdomain = domain;
  appdomain_thread_id.58 = appdomain_thread_id;
  mono_native_tls_set_value (appdomain_thread_id.58, domain);
  mono_gc_set_current_thread_appdomain (domain);
  D.22269 = mono_thread_internal_current ();
  D.22270 = mono_thread_internal_current ();
  D.22271 = &D.22270->current_appcontext;
  D.22272 = domain->default_context;
  mono_gc_wbarrier_set_field (D.22269, D.22271, D.22272);
  if (migrate_exception != 0) goto <D.22273>; else goto <D.22274>;
  <D.22273>:
  thread = mono_thread_internal_current ();
  D.22275 = thread->abort_exc;
  if (D.22275 == 0B) goto <D.22276>; else goto <D.22277>;
  <D.22276>:
  return;
  <D.22277>:
  D.22275 = thread->abort_exc;
  D.22278 = D.22275->object.vtable;
  D.22279 = D.22278->domain;
  D.22280 = D.22279 == domain;
  D.22281 = (long int) D.22280;
  D.22282 = __builtin_expect (D.22281, 0);
  if (D.22282 != 0) goto <D.22283>; else goto <D.22284>;
  <D.22283>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1830, "thread->abort_exc->object.vtable->domain != domain");
  <D.22284>:
  D.22285 = &thread->abort_exc;
  D.22286 = mono_get_exception_thread_abort ();
  mono_gc_wbarrier_set_field (thread, D.22285, D.22286);
  D.22275 = thread->abort_exc;
  D.22278 = D.22275->object.vtable;
  D.22279 = D.22278->domain;
  D.22287 = D.22279 != domain;
  D.22288 = (long int) D.22287;
  D.22289 = __builtin_expect (D.22288, 0);
  if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
  <D.22290>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1832, "thread->abort_exc->object.vtable->domain == domain");
  <D.22291>:
  <D.22274>:
}


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.22295;
  long int D.22296;
  long int D.22297;
  short unsigned int appdomain_list_size.59;
  unsigned int D.22301;
  unsigned int D.22302;
  struct MonoDomain * * appdomains_list.60;
  _Bool D.22306;
  long int D.22307;
  long int D.22308;
  unsigned int i.61;
  unsigned int D.22312;
  struct MonoDomain * * D.22313;
  struct MonoDomain * D.22314;
  int i;
  int size;
  struct MonoDomain * * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.22293>; else goto <D.22294>;
    <D.22293>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22294>:
    D.22295 = ret != 0;
    D.22296 = (long int) D.22295;
    D.22297 = __builtin_expect (D.22296, 0);
    if (D.22297 != 0) goto <D.22298>; else goto <D.22299>;
    <D.22298>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1859, "ret == 0");
    <D.22299>:
  }
  appdomain_list_size.59 = appdomain_list_size;
  size = (int) appdomain_list_size.59;
  appdomain_list_size.59 = appdomain_list_size;
  D.22301 = (unsigned int) appdomain_list_size.59;
  D.22302 = D.22301 * 4;
  copy = mono_gc_alloc_fixed (D.22302, 0B);
  appdomains_list.60 = appdomains_list;
  appdomain_list_size.59 = appdomain_list_size;
  D.22301 = (unsigned int) appdomain_list_size.59;
  D.22302 = D.22301 * 4;
  memcpy (copy, appdomains_list.60, D.22302);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.22304>; else goto <D.22305>;
    <D.22304>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22305>:
    D.22306 = ret != 0;
    D.22307 = (long int) D.22306;
    D.22308 = __builtin_expect (D.22307, 0);
    if (D.22308 != 0) goto <D.22309>; else goto <D.22310>;
    <D.22309>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1863, "ret == 0");
    <D.22310>:
  }
  i = 0;
  goto <D.20421>;
  <D.20420>:
  i.61 = (unsigned int) i;
  D.22312 = i.61 * 4;
  D.22313 = copy + D.22312;
  D.22314 = *D.22313;
  if (D.22314 != 0B) goto <D.22315>; else goto <D.22316>;
  <D.22315>:
  i.61 = (unsigned int) i;
  D.22312 = i.61 * 4;
  D.22313 = copy + D.22312;
  D.22314 = *D.22313;
  func (D.22314, user_data);
  <D.22316>:
  i = i + 1;
  <D.20421>:
  if (i < size) goto <D.20420>; else goto <D.20422>;
  <D.20422>:
  mono_gc_free_fixed (copy);
}


mono_domain_assembly_open (struct MonoDomain * domain, const char * name)
{
  union mono_mutex_t * D.22317;
  _Bool D.22320;
  long int D.22321;
  long int D.22322;
  int D.20439;
  const char * D.22325;
  _Bool D.22330;
  long int D.22331;
  long int D.22332;
  struct MonoAssembly * D.22335;
  _Bool D.22338;
  long int D.22339;
  long int D.22340;
  struct MonoDomain * D.22343;
  struct MonoDomain * current;
  struct MonoAssembly * ass;
  struct GSList * tmp;

  {
    int ret;

    D.22317 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.22317);
    if (ret != 0) goto <D.22318>; else goto <D.22319>;
    <D.22318>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22319>:
    D.22320 = ret != 0;
    D.22321 = (long int) D.22320;
    D.22322 = __builtin_expect (D.22321, 0);
    if (D.22322 != 0) goto <D.22323>; else goto <D.22324>;
    <D.22323>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1887, "ret == 0");
    <D.22324>:
  }
  tmp = domain->domain_assemblies;
  goto <D.20442>;
  <D.20441>:
  ass = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22325 = ass->aname.name;
    D.20439 = __builtin_strcmp (name, D.22325);
  }
  if (D.20439 == 0) goto <D.22326>; else goto <D.22327>;
  <D.22326>:
  {
    int ret;

    D.22317 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.22317);
    if (ret != 0) goto <D.22328>; else goto <D.22329>;
    <D.22328>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22329>:
    D.22330 = ret != 0;
    D.22331 = (long int) D.22330;
    D.22332 = __builtin_expect (D.22331, 0);
    if (D.22332 != 0) goto <D.22333>; else goto <D.22334>;
    <D.22333>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1891, "ret == 0");
    <D.22334>:
  }
  D.22335 = ass;
  return D.22335;
  <D.22327>:
  tmp = tmp->next;
  <D.20442>:
  if (tmp != 0B) goto <D.20441>; else goto <D.20443>;
  <D.20443>:
  {
    int ret;

    D.22317 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.22317);
    if (ret != 0) goto <D.22336>; else goto <D.22337>;
    <D.22336>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22337>:
    D.22338 = ret != 0;
    D.22339 = (long int) D.22338;
    D.22340 = __builtin_expect (D.22339, 0);
    if (D.22340 != 0) goto <D.22341>; else goto <D.22342>;
    <D.22341>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1895, "ret == 0");
    <D.22342>:
  }
  D.22343 = mono_domain_get ();
  if (D.22343 != domain) goto <D.22344>; else goto <D.22345>;
  <D.22344>:
  current = mono_domain_get ();
  mono_domain_set (domain, 0);
  ass = mono_assembly_open (name, 0B);
  mono_domain_set (current, 0);
  goto <D.22346>;
  <D.22345>:
  ass = mono_assembly_open (name, 0B);
  <D.22346>:
  D.22335 = ass;
  return D.22335;
}


mono_domain_free (struct MonoDomain * domain, gboolean force)
{
  struct MonoDomain * mono_root_domain.62;
  int mono_dont_free_domains.63;
  _Bool D.22358;
  long int D.22359;
  long int D.22360;
  struct MonoDomain * * appdomains_list.64;
  int D.22364;
  unsigned int D.22365;
  unsigned int D.22366;
  struct MonoDomain * * D.22367;
  _Bool D.22370;
  long int D.22371;
  long int D.22372;
  struct GHashTable * D.22375;
  struct MonoGHashTable * D.22378;
  struct MonoGHashTable * D.22379;
  struct MonoTlsDataRecord * D.22380;
  struct MonoGHashTable * D.22383;
  struct MonoGHashTable * D.22386;
  struct GPtrArray * D.22389;
  void * * D.22392;
  unsigned int i.65;
  unsigned int D.22394;
  void * * D.22395;
  void * D.22396;
  unsigned int i.66;
  unsigned int D.22398;
  struct MonoGHashTable * * D.22399;
  struct MonoImage * D.22402;
  unsigned char D.22404;
  unsigned char D.22405;
  char * D.22406;
  const char * D.22407;
  int D.22408;
  int D.22409;
  struct MonoImage * D.22416;
  unsigned char D.22418;
  unsigned char D.22419;
  const char * D.22420;
  int D.22421;
  int D.22422;
  struct GSList * D.22427;
  void (*<T23b9>) (struct MonoDomain *) free_domain_hook.67;
  gchar * * D.22431;
  struct GHashTable * D.22434;
  void * * D.22435;
  struct MonoInternalHashTable * D.22438;
  struct MonoJitInfoTable * D.22439;
  struct MonoJitInfoTable * D.22442;
  int D.22443;
  _Bool D.22444;
  long int D.22445;
  long int D.22446;
  struct MonoJitInfoTable * D.22449;
  struct GSList * D.22450;
  _Bool D.22451;
  long int D.22452;
  long int D.22453;
  struct MonoCodeManager * D.22456;
  int total_domain_code_alloc.68;
  int total_domain_code_alloc.69;
  int max_domain_code_alloc.70;
  int max_domain_code_alloc.71;
  int code_size.72;
  int max_domain_code_size.73;
  int max_domain_code_size.74;
  struct MonoMemPool * D.22464;
  struct LockFreeMempool * D.22465;
  struct GHashTable * D.22466;
  struct GHashTable * D.22467;
  struct GHashTable * D.22470;
  struct GHashTable * D.22473;
  struct GHashTable * D.22476;
  struct CRITICAL_SECTION * D.22479;
  struct CRITICAL_SECTION * D.22480;
  struct CRITICAL_SECTION * D.22481;
  struct CRITICAL_SECTION * D.22482;
  struct MonoPerfCounters * mono_perfcounters.75;
  unsigned int D.22484;
  unsigned int D.22485;
  int code_size;
  int code_alloc;
  struct GSList * tmp;
  void * * p;

  try
    {
      mono_root_domain.62 = mono_root_domain;
      if (domain == mono_root_domain.62) goto <D.22349>; else goto <D.22350>;
      <D.22349>:
      if (force == 0) goto <D.22351>; else goto <D.22352>;
      <D.22351>:
      monoeg_g_log (0B, 16, "cant unload root domain");
      return;
      <D.22352>:
      <D.22350>:
      mono_dont_free_domains.63 = mono_dont_free_domains;
      if (mono_dont_free_domains.63 != 0) goto <D.22354>; else goto <D.22355>;
      <D.22354>:
      return;
      <D.22355>:
      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.22356>; else goto <D.22357>;
        <D.22356>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22357>:
        D.22358 = ret != 0;
        D.22359 = (long int) D.22358;
        D.22360 = __builtin_expect (D.22359, 0);
        if (D.22360 != 0) goto <D.22361>; else goto <D.22362>;
        <D.22361>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1938, "ret == 0");
        <D.22362>:
      }
      appdomains_list.64 = appdomains_list;
      D.22364 = domain->domain_id;
      D.22365 = (unsigned int) D.22364;
      D.22366 = D.22365 * 4;
      D.22367 = appdomains_list.64 + D.22366;
      *D.22367 = 0B;
      {
        int ret;

        ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.22368>; else goto <D.22369>;
        <D.22368>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22369>:
        D.22370 = ret != 0;
        D.22371 = (long int) D.22370;
        D.22372 = __builtin_expect (D.22371, 0);
        if (D.22372 != 0) goto <D.22373>; else goto <D.22374>;
        <D.22373>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1940, "ret == 0");
        <D.22374>:
      }
      D.22375 = domain->special_static_fields;
      if (D.22375 != 0B) goto <D.22376>; else goto <D.22377>;
      <D.22376>:
      D.22375 = domain->special_static_fields;
      mono_alloc_special_static_data_free (D.22375);
      D.22375 = domain->special_static_fields;
      monoeg_g_hash_table_destroy (D.22375);
      domain->special_static_fields = 0B;
      <D.22377>:
      D.22378 = domain->ldstr_table;
      mono_g_hash_table_destroy (D.22378);
      domain->ldstr_table = 0B;
      D.22379 = domain->env;
      mono_g_hash_table_destroy (D.22379);
      domain->env = 0B;
      D.22380 = domain->tlsrec_list;
      if (D.22380 != 0B) goto <D.22381>; else goto <D.22382>;
      <D.22381>:
      mono_thread_destroy_domain_tls (domain);
      domain->tlsrec_list = 0B;
      <D.22382>:
      mono_reflection_cleanup_domain (domain);
      D.22383 = domain->type_hash;
      if (D.22383 != 0B) goto <D.22384>; else goto <D.22385>;
      <D.22384>:
      D.22383 = domain->type_hash;
      mono_g_hash_table_destroy (D.22383);
      domain->type_hash = 0B;
      <D.22385>:
      D.22386 = domain->type_init_exception_hash;
      if (D.22386 != 0B) goto <D.22387>; else goto <D.22388>;
      <D.22387>:
      D.22386 = domain->type_init_exception_hash;
      mono_g_hash_table_destroy (D.22386);
      domain->type_init_exception_hash = 0B;
      <D.22388>:
      D.22389 = domain->class_vtable_array;
      if (D.22389 != 0B) goto <D.22390>; else goto <D.22391>;
      <D.22390>:
      {
        int i;

        i = 0;
        goto <D.20461>;
        <D.20460>:
        D.22389 = domain->class_vtable_array;
        D.22392 = D.22389->pdata;
        i.65 = (unsigned int) i;
        D.22394 = i.65 * 4;
        D.22395 = D.22392 + D.22394;
        D.22396 = *D.22395;
        unregister_vtable_reflection_type (D.22396);
        i = i + 1;
        <D.20461>:
        i.66 = (unsigned int) i;
        D.22389 = domain->class_vtable_array;
        D.22398 = D.22389->len;
        if (i.66 < D.22398) goto <D.20460>; else goto <D.20462>;
        <D.20462>:
      }
      <D.22391>:
      tmp = domain->domain_assemblies;
      goto <D.20465>;
      <D.20464>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        mono_assembly_release_gc_roots (ass);
      }
      tmp = tmp->next;
      <D.20465>:
      if (tmp != 0B) goto <D.20464>; else goto <D.20466>;
      <D.20466>:
      p = &domain->setup;
      goto <D.20468>;
      <D.20467>:
      *p = 0B;
      p = p + 4;
      <D.20468>:
      D.22399 = &domain->env;
      if (D.22399 > p) goto <D.20467>; else goto <D.20469>;
      <D.20469>:
      mono_gc_clear_domain (domain);
      tmp = domain->domain_assemblies;
      goto <D.20473>;
      <D.20472>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        D.22402 = ass->image;
        if (D.22402 == 0B) goto <D.22400>; else goto <D.22403>;
        <D.22403>:
        D.22402 = ass->image;
        D.22404 = BIT_FIELD_REF <*D.22402, 8, 128>;
        D.22405 = D.22404 & 8;
        if (D.22405 == 0) goto <D.22400>; else goto <D.22401>;
        <D.22400>:
        // predicted unlikely by continue predictor.
        goto <D.20471>;
        <D.22401>:
        D.22406 = domain->friendly_name;
        D.22407 = ass->aname.name;
        D.22408 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.22406, domain, D.22407, ass, D.22408);
        D.22409 = mono_assembly_close_except_image_pools (ass);
        if (D.22409 == 0) goto <D.22410>; else goto <D.22411>;
        <D.22410>:
        tmp->data = 0B;
        <D.22411>:
      }
      <D.20471>:
      tmp = tmp->next;
      <D.20473>:
      if (tmp != 0B) goto <D.20472>; else goto <D.20474>;
      <D.20474>:
      tmp = domain->domain_assemblies;
      goto <D.20478>;
      <D.20477>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass == 0B) goto <D.22412>; else goto <D.22413>;
        <D.22412>:
        // predicted unlikely by continue predictor.
        goto <D.20476>;
        <D.22413>:
        D.22416 = ass->image;
        if (D.22416 == 0B) goto <D.22414>; else goto <D.22417>;
        <D.22417>:
        D.22416 = ass->image;
        D.22418 = BIT_FIELD_REF <*D.22416, 8, 128>;
        D.22419 = D.22418 & 8;
        if (D.22419 != 0) goto <D.22414>; else goto <D.22415>;
        <D.22414>:
        // predicted unlikely by continue predictor.
        goto <D.20476>;
        <D.22415>:
        D.22406 = domain->friendly_name;
        D.22420 = ass->aname.name;
        D.22421 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.22406, domain, D.22420, ass, D.22421);
        D.22422 = mono_assembly_close_except_image_pools (ass);
        if (D.22422 == 0) goto <D.22423>; else goto <D.22424>;
        <D.22423>:
        tmp->data = 0B;
        <D.22424>:
      }
      <D.20476>:
      tmp = tmp->next;
      <D.20478>:
      if (tmp != 0B) goto <D.20477>; else goto <D.20479>;
      <D.20479>:
      tmp = domain->domain_assemblies;
      goto <D.20482>;
      <D.20481>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass != 0B) goto <D.22425>; else goto <D.22426>;
        <D.22425>:
        mono_assembly_close_finish (ass);
        <D.22426>:
      }
      tmp = tmp->next;
      <D.20482>:
      if (tmp != 0B) goto <D.20481>; else goto <D.20483>;
      <D.20483>:
      D.22427 = domain->domain_assemblies;
      monoeg_g_slist_free (D.22427);
      domain->domain_assemblies = 0B;
      mono_profiler_appdomain_event (domain, 3);
      free_domain_hook.67 = free_domain_hook;
      if (free_domain_hook.67 != 0B) goto <D.22429>; else goto <D.22430>;
      <D.22429>:
      free_domain_hook.67 = free_domain_hook;
      free_domain_hook.67 (domain);
      <D.22430>:
      D.22431 = domain->search_path;
      if (D.22431 != 0B) goto <D.22432>; else goto <D.22433>;
      <D.22432>:
      D.22431 = domain->search_path;
      monoeg_g_strfreev (D.22431);
      domain->search_path = 0B;
      <D.22433>:
      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.22406 = domain->friendly_name;
      monoeg_g_free (D.22406);
      domain->friendly_name = 0B;
      D.22389 = domain->class_vtable_array;
      monoeg_g_ptr_array_free (D.22389, 1);
      domain->class_vtable_array = 0B;
      D.22434 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_destroy (D.22434);
      domain->proxy_vtable_hash = 0B;
      D.22435 = domain->static_data_array;
      if (D.22435 != 0B) goto <D.22436>; else goto <D.22437>;
      <D.22436>:
      D.22435 = domain->static_data_array;
      mono_gc_free_fixed (D.22435);
      domain->static_data_array = 0B;
      <D.22437>:
      D.22438 = &domain->jit_code_hash;
      mono_internal_hash_table_destroy (D.22438);
      mono_thread_hazardous_try_free_all ();
      D.22439 = domain->aot_modules;
      if (D.22439 != 0B) goto <D.22440>; else goto <D.22441>;
      <D.22440>:
      D.22442 = domain->aot_modules;
      jit_info_table_free (D.22442);
      <D.22441>:
      D.22443 = domain->num_jit_info_tables;
      D.22444 = D.22443 != 1;
      D.22445 = (long int) D.22444;
      D.22446 = __builtin_expect (D.22445, 0);
      if (D.22446 != 0) goto <D.22447>; else goto <D.22448>;
      <D.22447>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2068, "domain->num_jit_info_tables == 1");
      <D.22448>:
      D.22449 = domain->jit_info_table;
      jit_info_table_free (D.22449);
      domain->jit_info_table = 0B;
      D.22450 = domain->jit_info_free_queue;
      D.22451 = D.22450 != 0B;
      D.22452 = (long int) D.22451;
      D.22453 = __builtin_expect (D.22452, 0);
      if (D.22453 != 0) goto <D.22454>; else goto <D.22455>;
      <D.22454>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2071, "!domain->jit_info_free_queue");
      <D.22455>:
      D.22456 = domain->code_mp;
      code_alloc = mono_code_manager_size (D.22456, &code_size);
      total_domain_code_alloc.68 = total_domain_code_alloc;
      total_domain_code_alloc.69 = total_domain_code_alloc.68 + code_alloc;
      total_domain_code_alloc = total_domain_code_alloc.69;
      max_domain_code_alloc.70 = max_domain_code_alloc;
      max_domain_code_alloc.71 = MAX_EXPR <code_alloc, max_domain_code_alloc.70>;
      max_domain_code_alloc = max_domain_code_alloc.71;
      code_size.72 = code_size;
      max_domain_code_size.73 = max_domain_code_size;
      max_domain_code_size.74 = MAX_EXPR <code_size.72, max_domain_code_size.73>;
      max_domain_code_size = max_domain_code_size.74;
      D.22464 = domain->mp;
      mono_mempool_invalidate (D.22464);
      D.22456 = domain->code_mp;
      mono_code_manager_invalidate (D.22456);
      D.22465 = domain->lock_free_mp;
      lock_free_mempool_free (D.22465);
      domain->lock_free_mp = 0B;
      D.22466 = domain->finalizable_objects_hash;
      monoeg_g_hash_table_destroy (D.22466);
      domain->finalizable_objects_hash = 0B;
      D.22467 = domain->method_rgctx_hash;
      if (D.22467 != 0B) goto <D.22468>; else goto <D.22469>;
      <D.22468>:
      D.22467 = domain->method_rgctx_hash;
      monoeg_g_hash_table_destroy (D.22467);
      domain->method_rgctx_hash = 0B;
      <D.22469>:
      D.22470 = domain->generic_virtual_cases;
      if (D.22470 != 0B) goto <D.22471>; else goto <D.22472>;
      <D.22471>:
      D.22470 = domain->generic_virtual_cases;
      monoeg_g_hash_table_destroy (D.22470);
      domain->generic_virtual_cases = 0B;
      <D.22472>:
      D.22473 = domain->generic_virtual_thunks;
      if (D.22473 != 0B) goto <D.22474>; else goto <D.22475>;
      <D.22474>:
      D.22473 = domain->generic_virtual_thunks;
      monoeg_g_hash_table_destroy (D.22473);
      domain->generic_virtual_thunks = 0B;
      <D.22475>:
      D.22476 = domain->ftnptrs_hash;
      if (D.22476 != 0B) goto <D.22477>; else goto <D.22478>;
      <D.22477>:
      D.22476 = domain->ftnptrs_hash;
      monoeg_g_hash_table_destroy (D.22476);
      domain->ftnptrs_hash = 0B;
      <D.22478>:
      D.22479 = &domain->finalizable_objects_hash_lock;
      DeleteCriticalSection (D.22479);
      D.22480 = &domain->assemblies_lock;
      DeleteCriticalSection (D.22480);
      D.22481 = &domain->jit_code_hash_lock;
      DeleteCriticalSection (D.22481);
      D.22482 = &domain->lock;
      DeleteCriticalSection (D.22482);
      domain->setup = 0B;
      D.22399 = &domain->env;
      mono_gc_deregister_root (D.22399);
      mono_gc_free_fixed (domain);
      mono_perfcounters.75 = mono_perfcounters;
      D.22484 = mono_perfcounters.75->loader_appdomains;
      D.22485 = D.22484 + 4294967295;
      mono_perfcounters.75->loader_appdomains = D.22485;
      mono_root_domain.62 = mono_root_domain;
      if (domain == mono_root_domain.62) goto <D.22486>; else goto <D.22487>;
      <D.22486>:
      mono_root_domain = 0B;
      <D.22487>:
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


unregister_vtable_reflection_type (struct MonoVTable * vtable)
{
  struct MonoVTable * D.22491;
  struct MonoClass * D.22492;
  struct MonoClass * D.22493;
  int D.22496;
  void * * D.22499;
  struct MonoObject * type;

  type = vtable->type;
  D.22491 = type->vtable;
  D.22492 = D.22491->klass;
  D.22493 = mono_defaults.monotype_class;
  if (D.22492 != D.22493) goto <D.22494>; else goto <D.22495>;
  <D.22494>:
  D.22496 = mono_gc_is_moving ();
  if (D.22496 != 0) goto <D.22497>; else goto <D.22498>;
  <D.22497>:
  D.22499 = &vtable->type;
  mono_gc_deregister_root (D.22499);
  <D.22498>:
  <D.22495>:
}


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

  chunk = mp->chunks;
  goto <D.20271>;
  <D.20270>:
  next = chunk->prev;
  D.22500 = mono_pagesize ();
  D.22501 = (unsigned int) D.22500;
  mono_vfree (chunk, D.22501);
  chunk = next;
  <D.20271>:
  if (chunk != 0B) goto <D.20270>; else goto <D.20272>;
  <D.20272>:
}


mono_domain_get_by_id (gint32 domainid)
{
  _Bool D.22504;
  long int D.22505;
  long int D.22506;
  short unsigned int appdomain_list_size.76;
  int D.22510;
  struct MonoDomain * * appdomains_list.77;
  unsigned int domainid.78;
  unsigned int D.22515;
  struct MonoDomain * * D.22516;
  _Bool D.22520;
  long int D.22521;
  long int D.22522;
  struct MonoDomain * D.22525;
  struct MonoDomain * domain;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.22502>; else goto <D.22503>;
    <D.22502>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22503>:
    D.22504 = ret != 0;
    D.22505 = (long int) D.22504;
    D.22506 = __builtin_expect (D.22505, 0);
    if (D.22506 != 0) goto <D.22507>; else goto <D.22508>;
    <D.22507>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2144, "ret == 0");
    <D.22508>:
  }
  appdomain_list_size.76 = appdomain_list_size;
  D.22510 = (int) appdomain_list_size.76;
  if (D.22510 > domainid) goto <D.22511>; else goto <D.22512>;
  <D.22511>:
  appdomains_list.77 = appdomains_list;
  domainid.78 = (unsigned int) domainid;
  D.22515 = domainid.78 * 4;
  D.22516 = appdomains_list.77 + D.22515;
  domain = *D.22516;
  goto <D.22517>;
  <D.22512>:
  domain = 0B;
  <D.22517>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.22518>; else goto <D.22519>;
    <D.22518>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22519>:
    D.22520 = ret != 0;
    D.22521 = (long int) D.22520;
    D.22522 = __builtin_expect (D.22521, 0);
    if (D.22522 != 0) goto <D.22523>; else goto <D.22524>;
    <D.22523>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2149, "ret == 0");
    <D.22524>:
  }
  D.22525 = domain;
  return D.22525;
}


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

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


mono_domain_alloc (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.22529;
  _Bool D.22532;
  long int D.22533;
  long int D.22534;
  struct MonoPerfCounters * mono_perfcounters.79;
  unsigned int D.22538;
  unsigned int D.22539;
  struct MonoMemPool * D.22540;
  _Bool D.22543;
  long int D.22544;
  long int D.22545;
  void * D.22548;
  void * res;

  {
    int ret;

    D.22529 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22529);
    if (ret != 0) goto <D.22530>; else goto <D.22531>;
    <D.22530>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22531>:
    D.22532 = ret != 0;
    D.22533 = (long int) D.22532;
    D.22534 = __builtin_expect (D.22533, 0);
    if (D.22534 != 0) goto <D.22535>; else goto <D.22536>;
    <D.22535>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2170, "ret == 0");
    <D.22536>:
  }
  mono_perfcounters.79 = mono_perfcounters;
  mono_perfcounters.79 = mono_perfcounters;
  D.22538 = mono_perfcounters.79->loader_bytes;
  D.22539 = D.22538 + size;
  mono_perfcounters.79->loader_bytes = D.22539;
  D.22540 = domain->mp;
  res = mono_mempool_alloc (D.22540, size);
  {
    int ret;

    D.22529 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22529);
    if (ret != 0) goto <D.22541>; else goto <D.22542>;
    <D.22541>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22542>:
    D.22543 = ret != 0;
    D.22544 = (long int) D.22543;
    D.22545 = __builtin_expect (D.22544, 0);
    if (D.22545 != 0) goto <D.22546>; else goto <D.22547>;
    <D.22546>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2175, "ret == 0");
    <D.22547>:
  }
  D.22548 = res;
  return D.22548;
}


mono_domain_alloc0 (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.22550;
  _Bool D.22553;
  long int D.22554;
  long int D.22555;
  struct MonoPerfCounters * mono_perfcounters.80;
  unsigned int D.22559;
  unsigned int D.22560;
  struct MonoMemPool * D.22561;
  _Bool D.22564;
  long int D.22565;
  long int D.22566;
  void * D.22569;
  void * res;

  {
    int ret;

    D.22550 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22550);
    if (ret != 0) goto <D.22551>; else goto <D.22552>;
    <D.22551>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22552>:
    D.22553 = ret != 0;
    D.22554 = (long int) D.22553;
    D.22555 = __builtin_expect (D.22554, 0);
    if (D.22555 != 0) goto <D.22556>; else goto <D.22557>;
    <D.22556>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2190, "ret == 0");
    <D.22557>:
  }
  mono_perfcounters.80 = mono_perfcounters;
  mono_perfcounters.80 = mono_perfcounters;
  D.22559 = mono_perfcounters.80->loader_bytes;
  D.22560 = D.22559 + size;
  mono_perfcounters.80->loader_bytes = D.22560;
  D.22561 = domain->mp;
  res = mono_mempool_alloc0 (D.22561, size);
  {
    int ret;

    D.22550 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22550);
    if (ret != 0) goto <D.22562>; else goto <D.22563>;
    <D.22562>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22563>:
    D.22564 = ret != 0;
    D.22565 = (long int) D.22564;
    D.22566 = __builtin_expect (D.22565, 0);
    if (D.22566 != 0) goto <D.22567>; else goto <D.22568>;
    <D.22567>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2195, "ret == 0");
    <D.22568>:
  }
  D.22569 = res;
  return D.22569;
}


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

  D.22572 = domain->lock_free_mp;
  D.22571 = lock_free_mempool_alloc0 (D.22572, size);
  return D.22571;
}


lock_free_mempool_alloc0 (struct LockFreeMempool * mp, guint size)
{
  unsigned int D.22574;
  int size.81;
  int * D.22578;
  int size.82;
  unsigned int oldpos.83;
  unsigned int D.22581;
  int D.22582;
  unsigned int D.22583;
  int D.22586;
  unsigned int D.22587;
  unsigned int D.22588;
  _Bool D.22589;
  long int D.22590;
  long int D.22591;
  int D.22594;
  guint8 * D.22596;
  sizetype oldpos.84;
  void * D.22598;
  struct LockFreeMempoolChunk * chunk;
  void * res;
  int oldpos;

  D.22574 = size + 7;
  size = D.22574 & 4294967288;
  chunk = mp->current;
  if (chunk == 0B) goto <D.22575>; else goto <D.22576>;
  <D.22575>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  mono_memory_barrier ();
  mp->current = chunk;
  <D.22576>:
  D.22578 = &chunk->pos;
  size.82 = (int) size;
  oldpos = InterlockedExchangeAdd (D.22578, size.82);
  oldpos.83 = (unsigned int) oldpos;
  D.22581 = oldpos.83 + size;
  D.22582 = chunk->size;
  D.22583 = (unsigned int) D.22582;
  if (D.22581 > D.22583) goto <D.22584>; else goto <D.22585>;
  <D.22584>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  D.22586 = chunk->pos;
  D.22587 = (unsigned int) D.22586;
  D.22588 = D.22587 + size;
  D.22582 = chunk->size;
  D.22583 = (unsigned int) D.22582;
  D.22589 = D.22588 > D.22583;
  D.22590 = (long int) D.22589;
  D.22591 = __builtin_expect (D.22590, 0);
  if (D.22591 != 0) goto <D.22592>; else goto <D.22593>;
  <D.22592>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1085, "chunk->pos + size <= chunk->size");
  <D.22593>:
  res = chunk->mem;
  D.22586 = chunk->pos;
  D.22587 = (unsigned int) D.22586;
  D.22588 = D.22587 + size;
  D.22594 = (int) D.22588;
  chunk->pos = D.22594;
  mono_memory_barrier ();
  mp->current = chunk;
  goto <D.22595>;
  <D.22585>:
  D.22596 = chunk->mem;
  oldpos.84 = (sizetype) oldpos;
  res = D.22596 + oldpos.84;
  <D.22595>:
  D.22598 = res;
  return D.22598;
}


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

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


lock_free_mempool_chunk_new (struct LockFreeMempool * mp, int len)
{
  int D.22604;
  unsigned int size.86;
  unsigned int D.22606;
  unsigned int len.87;
  unsigned int size.88;
  _Bool D.22609;
  long int D.22610;
  long int D.22611;
  char * D.22614;
  int D.22615;
  int D.22616;
  int D.22617;
  guint8 * D.22618;
  sizetype size.89;
  char * D.22620;
  int D.22621;
  guint8 * D.22622;
  int D.22623;
  int D.22624;
  struct LockFreeMempoolChunk * * D.22625;
  void * D.22626;
  struct LockFreeMempoolChunk * D.22628;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * prev;
  int size;

  size = mono_pagesize ();
  goto <D.20281>;
  <D.20280>:
  D.22604 = mono_pagesize ();
  size = D.22604 + size;
  <D.20281>:
  size.86 = (unsigned int) size;
  D.22606 = size.86 + 4294967280;
  len.87 = (unsigned int) len;
  if (D.22606 < len.87) goto <D.20280>; else goto <D.20282>;
  <D.20282>:
  size.88 = (unsigned int) size;
  chunk = mono_valloc (0B, size.88, 3);
  D.22609 = chunk == 0B;
  D.22610 = (long int) D.22609;
  D.22611 = __builtin_expect (D.22610, 0);
  if (D.22611 != 0) goto <D.22612>; else goto <D.22613>;
  <D.22612>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1044, "chunk");
  <D.22613>:
  D.22614 = chunk + 16;
  D.22615 = (int) D.22614;
  D.22616 = D.22615 + 15;
  D.22617 = D.22616 & -16;
  D.22618 = (guint8 *) D.22617;
  chunk->mem = D.22618;
  size.89 = (sizetype) size;
  D.22620 = chunk + size.89;
  D.22621 = (int) D.22620;
  D.22622 = chunk->mem;
  D.22623 = (int) D.22622;
  D.22624 = D.22621 - D.22623;
  chunk->size = D.22624;
  chunk->pos = 0;
  <D.20284>:
  prev = mp->chunks;
  D.22625 = &mp->chunks;
  D.22626 = InterlockedCompareExchangePointer (D.22625, chunk, prev);
  if (D.22626 == prev) goto <D.20283>; else goto <D.22627>;
  <D.22627>:
  goto <D.20284>;
  <D.20283>:
  chunk->prev = prev;
  D.22628 = chunk;
  return D.22628;
}


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

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


mono_domain_code_reserve (struct MonoDomain * domain, int size)
{
  union mono_mutex_t * D.22635;
  _Bool D.22638;
  long int D.22639;
  long int D.22640;
  struct MonoCodeManager * D.22643;
  _Bool D.22646;
  long int D.22647;
  long int D.22648;
  void * D.22651;
  void * res;

  {
    int ret;

    D.22635 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22635);
    if (ret != 0) goto <D.22636>; else goto <D.22637>;
    <D.22636>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22637>:
    D.22638 = ret != 0;
    D.22639 = (long int) D.22638;
    D.22640 = __builtin_expect (D.22639, 0);
    if (D.22640 != 0) goto <D.22641>; else goto <D.22642>;
    <D.22641>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2216, "ret == 0");
    <D.22642>:
  }
  D.22643 = domain->code_mp;
  res = mono_code_manager_reserve (D.22643, size);
  {
    int ret;

    D.22635 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22635);
    if (ret != 0) goto <D.22644>; else goto <D.22645>;
    <D.22644>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22645>:
    D.22646 = ret != 0;
    D.22647 = (long int) D.22646;
    D.22648 = __builtin_expect (D.22647, 0);
    if (D.22648 != 0) goto <D.22649>; else goto <D.22650>;
    <D.22649>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2218, "ret == 0");
    <D.22650>:
  }
  D.22651 = res;
  return D.22651;
}


mono_domain_code_reserve_align (struct MonoDomain * domain, int size, int alignment)
{
  union mono_mutex_t * D.22653;
  _Bool D.22656;
  long int D.22657;
  long int D.22658;
  struct MonoCodeManager * D.22661;
  _Bool D.22664;
  long int D.22665;
  long int D.22666;
  void * D.22669;
  void * res;

  {
    int ret;

    D.22653 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22653);
    if (ret != 0) goto <D.22654>; else goto <D.22655>;
    <D.22654>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22655>:
    D.22656 = ret != 0;
    D.22657 = (long int) D.22656;
    D.22658 = __builtin_expect (D.22657, 0);
    if (D.22658 != 0) goto <D.22659>; else goto <D.22660>;
    <D.22659>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2233, "ret == 0");
    <D.22660>:
  }
  D.22661 = domain->code_mp;
  res = mono_code_manager_reserve_align (D.22661, size, alignment);
  {
    int ret;

    D.22653 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22653);
    if (ret != 0) goto <D.22662>; else goto <D.22663>;
    <D.22662>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22663>:
    D.22664 = ret != 0;
    D.22665 = (long int) D.22664;
    D.22666 = __builtin_expect (D.22665, 0);
    if (D.22666 != 0) goto <D.22667>; else goto <D.22668>;
    <D.22667>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2235, "ret == 0");
    <D.22668>:
  }
  D.22669 = res;
  return D.22669;
}


mono_domain_code_commit (struct MonoDomain * domain, void * data, int size, int newsize)
{
  union mono_mutex_t * D.22671;
  _Bool D.22674;
  long int D.22675;
  long int D.22676;
  struct MonoCodeManager * D.22679;
  _Bool D.22682;
  long int D.22683;
  long int D.22684;

  {
    int ret;

    D.22671 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22671);
    if (ret != 0) goto <D.22672>; else goto <D.22673>;
    <D.22672>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22673>:
    D.22674 = ret != 0;
    D.22675 = (long int) D.22674;
    D.22676 = __builtin_expect (D.22675, 0);
    if (D.22676 != 0) goto <D.22677>; else goto <D.22678>;
    <D.22677>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2248, "ret == 0");
    <D.22678>:
  }
  D.22679 = domain->code_mp;
  mono_code_manager_commit (D.22679, data, size, newsize);
  {
    int ret;

    D.22671 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22671);
    if (ret != 0) goto <D.22680>; else goto <D.22681>;
    <D.22680>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22681>:
    D.22682 = ret != 0;
    D.22683 = (long int) D.22682;
    D.22684 = __builtin_expect (D.22683, 0);
    if (D.22684 != 0) goto <D.22685>; else goto <D.22686>;
    <D.22685>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2250, "ret == 0");
    <D.22686>:
  }
}


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

  D.22687 = data;
  return D.22687;
}


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.22689;
  _Bool D.22692;
  long int D.22693;
  long int D.22694;
  struct MonoCodeManager * D.22697;
  _Bool D.22700;
  long int D.22701;
  long int D.22702;

  {
    int ret;

    D.22689 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22689);
    if (ret != 0) goto <D.22690>; else goto <D.22691>;
    <D.22690>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22691>:
    D.22692 = ret != 0;
    D.22693 = (long int) D.22692;
    D.22694 = __builtin_expect (D.22693, 0);
    if (D.22694 != 0) goto <D.22695>; else goto <D.22696>;
    <D.22695>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2317, "ret == 0");
    <D.22696>:
  }
  D.22697 = domain->code_mp;
  mono_code_manager_foreach (D.22697, func, user_data);
  {
    int ret;

    D.22689 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22689);
    if (ret != 0) goto <D.22698>; else goto <D.22699>;
    <D.22698>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22699>:
    D.22700 = ret != 0;
    D.22701 = (long int) D.22700;
    D.22702 = __builtin_expect (D.22701, 0);
    if (D.22702 != 0) goto <D.22703>; else goto <D.22704>;
    <D.22703>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2319, "ret == 0");
    <D.22704>:
  }
}


mono_context_set (struct MonoAppContext * new_context)
{
  struct MonoInternalThread * D.22705;
  struct MonoInternalThread * D.22706;
  struct MonoAppContext * * D.22707;

  D.22705 = mono_thread_internal_current ();
  D.22706 = mono_thread_internal_current ();
  D.22707 = &D.22706->current_appcontext;
  mono_gc_wbarrier_set_field (D.22705, D.22707, new_context);
}


mono_context_get ()
{
  struct MonoAppContext * D.22708;
  struct MonoInternalThread * D.22709;

  D.22709 = mono_thread_internal_current ();
  D.22708 = D.22709->current_appcontext;
  return D.22708;
}


mono_domain_add_class_static_data (struct MonoDomain * domain, struct MonoClass * klass, void * data, guint32 * bitmap)
{
  void * * D.22711;
  void * * D.22714;
  void * D.22715;
  void * D.22716;
  unsigned int size.92;
  unsigned int D.22720;
  void * iftmp.93;
  int D.22722;
  unsigned int D.22726;
  void * * D.22727;
  void * size.94;
  unsigned int size.95;
  unsigned int D.22731;
  void * iftmp.96;
  int D.22733;
  void * next.97;
  void * * D.22738;
  void * size.98;
  int next.99;
  unsigned int next.100;
  unsigned int D.22742;
  void * * D.22743;
  int next;

  D.22711 = domain->static_data_array;
  if (D.22711 != 0B) goto <D.22712>; else goto <D.22713>;
  <D.22712>:
  {
    int size;

    D.22711 = domain->static_data_array;
    D.22714 = D.22711 + 4;
    D.22715 = *D.22714;
    size = (int) D.22715;
    D.22711 = domain->static_data_array;
    D.22716 = *D.22711;
    next = (int) D.22716;
    if (next >= size) goto <D.22717>; else goto <D.22718>;
    <D.22717>:
    {
      void * * new_array;

      size.92 = (unsigned int) size;
      D.22720 = size.92 * 8;
      D.22722 = mono_gc_is_moving ();
      if (D.22722 != 0) goto <D.22723>; else goto <D.22724>;
      <D.22723>:
      iftmp.93 = mono_gc_make_root_descr_all_refs (0);
      goto <D.22725>;
      <D.22724>:
      iftmp.93 = 0B;
      <D.22725>:
      new_array = mono_gc_alloc_fixed (D.22720, iftmp.93);
      D.22711 = domain->static_data_array;
      size.92 = (unsigned int) size;
      D.22726 = size.92 * 4;
      mono_gc_memmove_aligned (new_array, D.22711, D.22726);
      size = size * 2;
      D.22727 = new_array + 4;
      size.94 = (void *) size;
      *D.22727 = size.94;
      D.22711 = domain->static_data_array;
      mono_gc_free_fixed (D.22711);
      domain->static_data_array = new_array;
    }
    <D.22718>:
  }
  goto <D.22729>;
  <D.22713>:
  {
    int size;
    void * * new_array;

    size = 32;
    size.95 = (unsigned int) size;
    D.22731 = size.95 * 4;
    D.22733 = mono_gc_is_moving ();
    if (D.22733 != 0) goto <D.22734>; else goto <D.22735>;
    <D.22734>:
    iftmp.96 = mono_gc_make_root_descr_all_refs (0);
    goto <D.22736>;
    <D.22735>:
    iftmp.96 = 0B;
    <D.22736>:
    new_array = mono_gc_alloc_fixed (D.22731, iftmp.96);
    next = 2;
    next.97 = (void *) next;
    *new_array = next.97;
    D.22738 = new_array + 4;
    size.98 = (void *) size;
    *D.22738 = size.98;
    domain->static_data_array = new_array;
  }
  <D.22729>:
  D.22711 = domain->static_data_array;
  next.99 = next;
  next = next.99 + 1;
  next.100 = (unsigned int) next.99;
  D.22742 = next.100 * 4;
  D.22743 = D.22711 + D.22742;
  *D.22743 = data;
  D.22711 = domain->static_data_array;
  next.97 = (void *) next;
  *D.22711 = next.97;
}


mono_get_corlib ()
{
  struct MonoImage * D.22744;

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


mono_get_object_class ()
{
  struct MonoClass * D.22746;

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


mono_get_byte_class ()
{
  struct MonoClass * D.22748;

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


mono_get_void_class ()
{
  struct MonoClass * D.22750;

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


mono_get_boolean_class ()
{
  struct MonoClass * D.22752;

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


mono_get_sbyte_class ()
{
  struct MonoClass * D.22754;

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


mono_get_int16_class ()
{
  struct MonoClass * D.22756;

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


mono_get_uint16_class ()
{
  struct MonoClass * D.22758;

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


mono_get_int32_class ()
{
  struct MonoClass * D.22760;

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


mono_get_uint32_class ()
{
  struct MonoClass * D.22762;

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


mono_get_intptr_class ()
{
  struct MonoClass * D.22764;

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


mono_get_uintptr_class ()
{
  struct MonoClass * D.22766;

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


mono_get_int64_class ()
{
  struct MonoClass * D.22768;

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


mono_get_uint64_class ()
{
  struct MonoClass * D.22770;

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


mono_get_single_class ()
{
  struct MonoClass * D.22772;

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


mono_get_double_class ()
{
  struct MonoClass * D.22774;

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


mono_get_char_class ()
{
  struct MonoClass * D.22776;

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


mono_get_string_class ()
{
  struct MonoClass * D.22778;

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


mono_get_enum_class ()
{
  struct MonoClass * D.22780;

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


mono_get_array_class ()
{
  struct MonoClass * D.22782;

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


mono_get_thread_class ()
{
  struct MonoClass * D.22784;

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


mono_get_exception_class ()
{
  struct MonoClass * D.22786;

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


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

  D.22788 = current_runtime;
  return D.22788;
}


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


mono_framework_version ()
{
  int D.22800;
  const struct MonoRuntimeInfo * current_runtime.102;
  char D.22802;
  int D.22803;

  current_runtime.102 = current_runtime;
  D.22802 = current_runtime.102->framework_version[0];
  D.22803 = (int) D.22802;
  D.22800 = D.22803 + -48;
  return D.22800;
}