mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


codechunk_cleanup ()
{
  struct GHashTable * valloc_freelists.0;
  void * key.1;
  unsigned int key.2;
  void * D.14008;
  int D.14009;
  struct GHashTableIter iter;
  void * key;
  void * value;

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.14004>; else goto <D.14005>;
      <D.14004>:
      return;
      <D.14005>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.13900>;
      <D.13899>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.13897>;
        <D.13896>:
        key.1 = key;
        key.2 = (unsigned int) key.1;
        D.14008 = l->data;
        mono_vfree (D.14008, key.2);
        l = l->next;
        <D.13897>:
        if (l != 0B) goto <D.13896>; else goto <D.13898>;
        <D.13898>:
        monoeg_g_slist_free (freelist);
      }
      <D.13900>:
      D.14009 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.14009 != 0) goto <D.13899>; else goto <D.13901>;
      <D.13901>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_destroy (valloc_freelists.0);
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
      value = {CLOBBER};
    }
}


mono_code_manager_new ()
{
  struct MonoCodeManager * D.14015;
  struct MonoCodeManager * cman;

  cman = malloc (16);
  if (cman == 0B) goto <D.14013>; else goto <D.14014>;
  <D.14013>:
  D.14015 = 0B;
  return D.14015;
  <D.14014>:
  cman->current = 0B;
  cman->full = 0B;
  cman->dynamic = 0;
  cman->read_only = 0;
  D.14015 = cman;
  return D.14015;
}


mono_code_manager_new_dynamic ()
{
  struct MonoCodeManager * D.14017;
  struct MonoCodeManager * cman;

  cman = mono_code_manager_new ();
  cman->dynamic = 1;
  D.14017 = cman;
  return D.14017;
}


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.14019;
  struct CodeChunk * D.14020;

  D.14019 = cman->full;
  free_chunklist (D.14019);
  D.14020 = cman->current;
  free_chunklist (D.14020);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.14021;
  unsigned char D.14022;
  int D.14025;
  unsigned int D.14026;
  unsigned int code_memory_used.3;
  unsigned int D.14031;
  unsigned int code_memory_used.4;
  struct CodeChunk * dead;

  goto <D.13921>;
  <D.13920>:
  dead = chunk;
  D.14021 = dead->data;
  mono_profiler_code_chunk_destroy (D.14021);
  chunk = chunk->next;
  D.14022 = dead->flags;
  if (D.14022 == 0) goto <D.14023>; else goto <D.14024>;
  <D.14023>:
  D.14025 = dead->size;
  D.14026 = (unsigned int) D.14025;
  D.14021 = dead->data;
  codechunk_vfree (D.14021, D.14026);
  goto <D.14027>;
  <D.14024>:
  D.14022 = dead->flags;
  if (D.14022 == 1) goto <D.14028>; else goto <D.14029>;
  <D.14028>:
  D.14021 = dead->data;
  dlfree (D.14021);
  <D.14029>:
  <D.14027>:
  code_memory_used.3 = code_memory_used;
  D.14025 = dead->size;
  D.14031 = (unsigned int) D.14025;
  code_memory_used.4 = code_memory_used.3 - D.14031;
  code_memory_used = code_memory_used.4;
  free (dead);
  <D.13921>:
  if (chunk != 0B) goto <D.13920>; else goto <D.13922>;
  <D.13922>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.14035;
  long int D.14036;
  long int D.14037;
  const void * size.5;
  struct GHashTable * valloc_freelists.6;
  unsigned int D.14046;
  void * size.7;
  _Bool D.14050;
  long int D.14051;
  long int D.14052;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14033>; else goto <D.14034>;
    <D.14033>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14034>:
    D.14035 = ret != 0;
    D.14036 = (long int) D.14035;
    D.14037 = __builtin_expect (D.14036, 0);
    if (D.14037 != 0) goto <D.14038>; else goto <D.14039>;
    <D.14038>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.14039>:
  }
  size.5 = (const void *) size;
  valloc_freelists.6 = valloc_freelists;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.6, size.5);
  if (freelist == 0B) goto <D.14042>; else goto <D.14045>;
  <D.14045>:
  D.14046 = monoeg_g_slist_length (freelist);
  if (D.14046 <= 15) goto <D.14042>; else goto <D.14043>;
  <D.14042>:
  freelist = monoeg_g_slist_prepend (freelist, ptr);
  size.7 = (void *) size;
  valloc_freelists.6 = valloc_freelists;
  monoeg_g_hash_table_insert_replace (valloc_freelists.6, size.7, freelist, 0);
  goto <D.14044>;
  <D.14043>:
  mono_vfree (ptr, size);
  <D.14044>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14048>; else goto <D.14049>;
    <D.14048>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14049>:
    D.14050 = ret != 0;
    D.14051 = (long int) D.14050;
    D.14052 = __builtin_expect (D.14051, 0);
    if (D.14052 != 0) goto <D.14053>; else goto <D.14054>;
    <D.14053>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.14054>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  int D.14055;
  unsigned int D.14056;
  char * D.14057;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 204;
  chunk = cman->current;
  goto <D.13932>;
  <D.13931>:
  D.14055 = chunk->size;
  D.14056 = (unsigned int) D.14055;
  D.14057 = chunk->data;
  memset (D.14057, fill_value, D.14056);
  chunk = chunk->next;
  <D.13932>:
  if (chunk != 0B) goto <D.13931>; else goto <D.13933>;
  <D.13933>:
  chunk = cman->full;
  goto <D.13935>;
  <D.13934>:
  D.14055 = chunk->size;
  D.14056 = (unsigned int) D.14055;
  D.14057 = chunk->data;
  memset (D.14057, fill_value, D.14056);
  chunk = chunk->next;
  <D.13935>:
  if (chunk != 0B) goto <D.13934>; else goto <D.13936>;
  <D.13936>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14060;
  int D.14065;
  void * D.14067;
  unsigned int D.14068;

  D.14060 = __builtin_constant_p (__len);
  if (D.14060 != 0) goto <D.14061>; else goto <D.14062>;
  <D.14061>:
  if (__len == 0) goto <D.14063>; else goto <D.14064>;
  <D.14063>:
  D.14065 = __builtin_constant_p (__ch);
  if (D.14065 == 0) goto <D.14058>; else goto <D.14066>;
  <D.14066>:
  if (__ch != 0) goto <D.14058>; else goto <D.14059>;
  <D.14058>:
  __warn_memset_zero_len ();
  D.14067 = __dest;
  return D.14067;
  <D.14059>:
  <D.14064>:
  <D.14062>:
  D.14068 = __builtin_object_size (__dest, 0);
  D.14067 = __builtin___memset_chk (__dest, __ch, __len, D.14068);
  return D.14067;
}


mono_code_manager_set_read_only (struct MonoCodeManager * cman)
{
  cman->read_only = 1;
}


mono_code_manager_foreach (struct MonoCodeManager * cman, int (*MonoCodeManagerFunc) (void *, int, int, void *) func, void * user_data)
{
  <unnamed-unsigned:24> D.14070;
  int D.14071;
  int D.14072;
  char * D.14073;
  int D.14074;
  int D.14077;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.13947>;
  <D.13946>:
  D.14070 = chunk->bsize;
  D.14071 = (int) D.14070;
  D.14072 = chunk->size;
  D.14073 = chunk->data;
  D.14074 = func (D.14073, D.14072, D.14071, user_data);
  if (D.14074 != 0) goto <D.14075>; else goto <D.14076>;
  <D.14075>:
  return;
  <D.14076>:
  chunk = chunk->next;
  <D.13947>:
  if (chunk != 0B) goto <D.13946>; else goto <D.13948>;
  <D.13948>:
  chunk = cman->full;
  goto <D.13950>;
  <D.13949>:
  D.14070 = chunk->bsize;
  D.14071 = (int) D.14070;
  D.14072 = chunk->size;
  D.14073 = chunk->data;
  D.14077 = func (D.14073, D.14072, D.14071, user_data);
  if (D.14077 != 0) goto <D.14078>; else goto <D.14079>;
  <D.14078>:
  return;
  <D.14079>:
  chunk = chunk->next;
  <D.13950>:
  if (chunk != 0B) goto <D.13949>; else goto <D.13951>;
  <D.13951>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.14081;
  int D.14082;
  _Bool D.14083;
  long int D.14084;
  long int D.14085;
  _Bool D.14088;
  long int D.14089;
  long int D.14090;
  int D.14093;
  long unsigned int D.14096;
  long unsigned int D.14097;
  long unsigned int D.14098;
  long unsigned int size.8;
  long unsigned int D.14100;
  struct CodeChunk * D.14101;
  struct CodeChunk * D.14104;
  void * D.14107;
  int D.14108;
  int D.14109;
  int D.14110;
  int D.14111;
  int D.14112;
  int D.14113;
  char * D.14116;
  unsigned int D.14117;
  unsigned int D.14118;
  unsigned int D.14119;
  unsigned int D.14120;
  unsigned int D.14121;
  unsigned int D.14122;
  int ptr.9;
  int D.14124;
  int D.14125;
  int D.14126;
  int D.14127;
  struct CodeChunk * D.14132;
  struct CodeChunk * D.14134;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.14081 = alignment + -1;
  align_mask = (guint32) D.14081;
  D.14082 = cman->read_only;
  D.14083 = D.14082 != 0;
  D.14084 = (long int) D.14083;
  D.14085 = __builtin_expect (D.14084, 0);
  if (D.14085 != 0) goto <D.14086>; else goto <D.14087>;
  <D.14086>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.14087>:
  D.14088 = alignment > 8;
  D.14089 = (long int) D.14088;
  D.14090 = __builtin_expect (D.14089, 0);
  if (D.14090 != 0) goto <D.14091>; else goto <D.14092>;
  <D.14091>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.14092>:
  D.14093 = cman->dynamic;
  if (D.14093 != 0) goto <D.14094>; else goto <D.14095>;
  <D.14094>:
  D.14096 = mono_stats.dynamic_code_alloc_count;
  D.14097 = D.14096 + 1;
  mono_stats.dynamic_code_alloc_count = D.14097;
  D.14098 = mono_stats.dynamic_code_bytes_count;
  size.8 = (long unsigned int) size;
  D.14100 = D.14098 + size.8;
  mono_stats.dynamic_code_bytes_count = D.14100;
  <D.14095>:
  D.14101 = cman->current;
  if (D.14101 == 0B) goto <D.14102>; else goto <D.14103>;
  <D.14102>:
  D.14093 = cman->dynamic;
  D.14104 = new_codechunk (D.14093, size);
  cman->current = D.14104;
  D.14101 = cman->current;
  if (D.14101 == 0B) goto <D.14105>; else goto <D.14106>;
  <D.14105>:
  D.14107 = 0B;
  return D.14107;
  <D.14106>:
  <D.14103>:
  chunk = cman->current;
  goto <D.13973>;
  <D.13972>:
  D.14108 = chunk->pos;
  D.14081 = alignment + -1;
  D.14109 = D.14108 + D.14081;
  D.14110 = -alignment;
  D.14111 = D.14109 & D.14110;
  D.14112 = D.14111 + size;
  D.14113 = chunk->size;
  if (D.14112 <= D.14113) goto <D.14114>; else goto <D.14115>;
  <D.14114>:
  D.14108 = chunk->pos;
  D.14081 = alignment + -1;
  D.14109 = D.14108 + D.14081;
  D.14110 = -alignment;
  D.14111 = D.14109 & D.14110;
  chunk->pos = D.14111;
  D.14116 = chunk->data;
  D.14117 = (unsigned int) D.14116;
  D.14118 = D.14117 + align_mask;
  D.14119 = ~align_mask;
  D.14120 = D.14118 & D.14119;
  D.14108 = chunk->pos;
  D.14121 = (unsigned int) D.14108;
  D.14122 = D.14120 + D.14121;
  ptr = (void *) D.14122;
  ptr.9 = (int) ptr;
  D.14116 = chunk->data;
  D.14124 = (int) D.14116;
  D.14125 = ptr.9 - D.14124;
  D.14126 = D.14125 + size;
  chunk->pos = D.14126;
  D.14107 = ptr;
  return D.14107;
  <D.14115>:
  chunk = chunk->next;
  <D.13973>:
  if (chunk != 0B) goto <D.13972>; else goto <D.13974>;
  <D.13974>:
  prev = 0B;
  chunk = cman->current;
  goto <D.13978>;
  <D.13977>:
  D.14108 = chunk->pos;
  D.14127 = D.14108 + 31;
  D.14113 = chunk->size;
  if (D.14127 < D.14113) goto <D.14128>; else goto <D.14129>;
  <D.14128>:
  // predicted unlikely by continue predictor.
  goto <D.13975>;
  <D.14129>:
  if (prev != 0B) goto <D.14130>; else goto <D.14131>;
  <D.14130>:
  D.14132 = chunk->next;
  prev->next = D.14132;
  goto <D.14133>;
  <D.14131>:
  D.14132 = chunk->next;
  cman->current = D.14132;
  <D.14133>:
  D.14134 = cman->full;
  chunk->next = D.14134;
  cman->full = chunk;
  goto <D.13976>;
  <D.13975>:
  prev = chunk;
  chunk = chunk->next;
  <D.13978>:
  if (chunk != 0B) goto <D.13977>; else goto <D.13976>;
  <D.13976>:
  D.14093 = cman->dynamic;
  chunk = new_codechunk (D.14093, size);
  if (chunk == 0B) goto <D.14135>; else goto <D.14136>;
  <D.14135>:
  D.14107 = 0B;
  return D.14107;
  <D.14136>:
  D.14101 = cman->current;
  chunk->next = D.14101;
  cman->current = chunk;
  D.14108 = chunk->pos;
  D.14081 = alignment + -1;
  D.14109 = D.14108 + D.14081;
  D.14110 = -alignment;
  D.14111 = D.14109 & D.14110;
  chunk->pos = D.14111;
  D.14116 = chunk->data;
  D.14117 = (unsigned int) D.14116;
  D.14118 = D.14117 + align_mask;
  D.14119 = ~align_mask;
  D.14120 = D.14118 & D.14119;
  D.14108 = chunk->pos;
  D.14121 = (unsigned int) D.14108;
  D.14122 = D.14120 + D.14121;
  ptr = (void *) D.14122;
  ptr.9 = (int) ptr;
  D.14116 = chunk->data;
  D.14124 = (int) D.14116;
  D.14125 = ptr.9 - D.14124;
  D.14126 = D.14125 + size;
  chunk->pos = D.14126;
  D.14107 = ptr;
  return D.14107;
}


new_codechunk (int dynamic, int size)
{
  int D.14144;
  int D.14145;
  int D.14148;
  unsigned int D.14149;
  struct CodeChunk * D.14152;
  unsigned int chunk_size.10;
  unsigned int chunk_size.11;
  unsigned char D.14165;
  unsigned int bsize.12;
  <unnamed-unsigned:24> D.14167;
  int D.14168;
  char * D.14169;
  unsigned int code_memory_used.13;
  unsigned int chunk_size.14;
  unsigned int code_memory_used.15;
  int minsize;
  int flags;
  int chunk_size;
  int bsize;
  int pagesize;
  struct CodeChunk * chunk;
  void * ptr;

  flags = 0;
  bsize = 0;
  pagesize = mono_pagesize ();
  if (dynamic != 0) goto <D.14138>; else goto <D.14139>;
  <D.14138>:
  chunk_size = size;
  flags = 1;
  goto <D.14140>;
  <D.14139>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.14141>; else goto <D.14142>;
  <D.14141>:
  chunk_size = minsize;
  goto <D.14143>;
  <D.14142>:
  chunk_size = size;
  D.14144 = pagesize + -1;
  chunk_size = D.14144 + chunk_size;
  D.14145 = -pagesize;
  chunk_size = D.14145 & chunk_size;
  <D.14143>:
  <D.14140>:
  if (flags == 1) goto <D.14146>; else goto <D.14147>;
  <D.14146>:
  D.14148 = chunk_size + 7;
  D.14149 = (unsigned int) D.14148;
  ptr = dlmemalign (8, D.14149);
  if (ptr == 0B) goto <D.14150>; else goto <D.14151>;
  <D.14150>:
  D.14152 = 0B;
  return D.14152;
  <D.14151>:
  goto <D.14153>;
  <D.14147>:
  chunk_size.10 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.10);
  if (ptr == 0B) goto <D.14155>; else goto <D.14156>;
  <D.14155>:
  D.14152 = 0B;
  return D.14152;
  <D.14156>:
  <D.14153>:
  if (flags == 1) goto <D.14157>; else goto <D.14158>;
  <D.14157>:
  <D.14158>:
  chunk = malloc (20);
  if (chunk == 0B) goto <D.14159>; else goto <D.14160>;
  <D.14159>:
  if (flags == 1) goto <D.14161>; else goto <D.14162>;
  <D.14161>:
  dlfree (ptr);
  goto <D.14163>;
  <D.14162>:
  chunk_size.11 = (unsigned int) chunk_size;
  mono_vfree (ptr, chunk_size.11);
  <D.14163>:
  D.14152 = 0B;
  return D.14152;
  <D.14160>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.14165 = (unsigned char) flags;
  chunk->flags = D.14165;
  chunk->pos = bsize;
  bsize.12 = (unsigned int) bsize;
  D.14167 = (<unnamed-unsigned:24>) bsize.12;
  chunk->bsize = D.14167;
  D.14168 = chunk->size;
  D.14169 = chunk->data;
  mono_profiler_code_chunk_new (D.14169, D.14168);
  code_memory_used.13 = code_memory_used;
  chunk_size.14 = (unsigned int) chunk_size;
  code_memory_used.15 = code_memory_used.13 + chunk_size.14;
  code_memory_used = code_memory_used.15;
  code_memory_used.13 = code_memory_used;
  mono_runtime_resource_check_limit (0, code_memory_used.13);
  D.14152 = chunk;
  return D.14152;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.16;
  struct GHashTable * valloc_freelists.17;
  _Bool D.14180;
  long int D.14181;
  long int D.14182;
  const void * size.18;
  void * size.19;
  unsigned int D.14190;
  _Bool D.14193;
  long int D.14194;
  long int D.14195;
  void * D.14198;
  void * ptr;
  struct GSList * freelist;

  valloc_freelists.16 = valloc_freelists;
  if (valloc_freelists.16 == 0B) goto <D.14175>; else goto <D.14176>;
  <D.14175>:
  InitializeCriticalSection (&valloc_mutex);
  valloc_freelists.17 = monoeg_g_hash_table_new (0B, 0B);
  valloc_freelists = valloc_freelists.17;
  <D.14176>:
  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14178>; else goto <D.14179>;
    <D.14178>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14179>:
    D.14180 = ret != 0;
    D.14181 = (long int) D.14180;
    D.14182 = __builtin_expect (D.14181, 0);
    if (D.14182 != 0) goto <D.14183>; else goto <D.14184>;
    <D.14183>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.14184>:
  }
  size.18 = (const void *) size;
  valloc_freelists.16 = valloc_freelists;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.16, size.18);
  if (freelist != 0B) goto <D.14186>; else goto <D.14187>;
  <D.14186>:
  ptr = freelist->data;
  memset (ptr, 0, size);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  size.19 = (void *) size;
  valloc_freelists.16 = valloc_freelists;
  monoeg_g_hash_table_insert_replace (valloc_freelists.16, size.19, freelist, 0);
  goto <D.14189>;
  <D.14187>:
  D.14190 = size + 7;
  ptr = mono_valloc (0B, D.14190, 7);
  <D.14189>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14191>; else goto <D.14192>;
    <D.14191>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14192>:
    D.14193 = ret != 0;
    D.14194 = (long int) D.14193;
    D.14195 = __builtin_expect (D.14194, 0);
    if (D.14195 != 0) goto <D.14196>; else goto <D.14197>;
    <D.14196>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.14197>:
  }
  D.14198 = ptr;
  return D.14198;
}


mono_code_manager_reserve (struct MonoCodeManager * cman, int size)
{
  void * D.14200;

  D.14200 = mono_code_manager_reserve_align (cman, size, 8);
  return D.14200;
}


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.14202;
  long int D.14203;
  long int D.14204;
  struct CodeChunk * D.14207;
  char * D.14212;
  int D.14213;
  sizetype D.14214;
  sizetype size.20;
  sizetype D.14216;
  char * D.14217;
  int D.14220;
  int D.14221;

  D.14202 = newsize > size;
  D.14203 = (long int) D.14202;
  D.14204 = __builtin_expect (D.14203, 0);
  if (D.14204 != 0) goto <D.14205>; else goto <D.14206>;
  <D.14205>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 702, "newsize <= size");
  <D.14206>:
  D.14207 = cman->current;
  if (D.14207 != 0B) goto <D.14208>; else goto <D.14209>;
  <D.14208>:
  if (size != newsize) goto <D.14210>; else goto <D.14211>;
  <D.14210>:
  D.14207 = cman->current;
  D.14212 = D.14207->data;
  D.14207 = cman->current;
  D.14213 = D.14207->pos;
  D.14214 = (sizetype) D.14213;
  size.20 = (sizetype) size;
  D.14216 = D.14214 - size.20;
  D.14217 = D.14212 + D.14216;
  if (D.14217 == data) goto <D.14218>; else goto <D.14219>;
  <D.14218>:
  D.14207 = cman->current;
  D.14207 = cman->current;
  D.14213 = D.14207->pos;
  D.14220 = newsize - size;
  D.14221 = D.14213 + D.14220;
  D.14207->pos = D.14221;
  <D.14219>:
  <D.14211>:
  <D.14209>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.14222;
  unsigned int D.14223;
  int D.14224;
  unsigned int D.14225;
  int used.21;
  int D.14229;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.13997>;
  <D.13996>:
  D.14222 = chunk->size;
  D.14223 = (unsigned int) D.14222;
  size = D.14223 + size;
  D.14224 = chunk->pos;
  D.14225 = (unsigned int) D.14224;
  used = D.14225 + used;
  chunk = chunk->next;
  <D.13997>:
  if (chunk != 0B) goto <D.13996>; else goto <D.13998>;
  <D.13998>:
  chunk = cman->full;
  goto <D.14000>;
  <D.13999>:
  D.14222 = chunk->size;
  D.14223 = (unsigned int) D.14222;
  size = D.14223 + size;
  D.14224 = chunk->pos;
  D.14225 = (unsigned int) D.14224;
  used = D.14225 + used;
  chunk = chunk->next;
  <D.14000>:
  if (chunk != 0B) goto <D.13999>; else goto <D.14001>;
  <D.14001>:
  if (used_size != 0B) goto <D.14226>; else goto <D.14227>;
  <D.14226>:
  used.21 = (int) used;
  *used_size = used.21;
  <D.14227>:
  D.14229 = (int) size;
  return D.14229;
}