mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


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

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.14032>; else goto <D.14033>;
      <D.14032>:
      return;
      <D.14033>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.13928>;
      <D.13927>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.13925>;
        <D.13924>:
        D.14034 = l->data;
        key.1 = key;
        key.2 = (unsigned int) key.1;
        mono_vfree (D.14034, key.2);
        l = l->next;
        <D.13925>:
        if (l != 0B) goto <D.13924>; else goto <D.13926>;
        <D.13926>:
        monoeg_g_slist_free (freelist);
      }
      <D.13928>:
      D.14037 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.14037 != 0) goto <D.13927>; else goto <D.13929>;
      <D.13929>:
      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.14043;
  struct MonoCodeManager * cman;

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


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

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


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.14047;
  struct CodeChunk * D.14048;

  D.14047 = cman->full;
  free_chunklist (D.14047);
  D.14048 = cman->current;
  free_chunklist (D.14048);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.14049;
  unsigned char D.14050;
  int D.14053;
  unsigned int D.14054;
  unsigned int code_memory_used.3;
  unsigned int D.14059;
  unsigned int code_memory_used.4;
  struct CodeChunk * dead;

  goto <D.13949>;
  <D.13948>:
  dead = chunk;
  D.14049 = dead->data;
  mono_profiler_code_chunk_destroy (D.14049);
  chunk = chunk->next;
  D.14050 = dead->flags;
  if (D.14050 == 0) goto <D.14051>; else goto <D.14052>;
  <D.14051>:
  D.14049 = dead->data;
  D.14053 = dead->size;
  D.14054 = (unsigned int) D.14053;
  codechunk_vfree (D.14049, D.14054);
  goto <D.14055>;
  <D.14052>:
  D.14050 = dead->flags;
  if (D.14050 == 1) goto <D.14056>; else goto <D.14057>;
  <D.14056>:
  D.14049 = dead->data;
  dlfree (D.14049);
  <D.14057>:
  <D.14055>:
  code_memory_used.3 = code_memory_used;
  D.14053 = dead->size;
  D.14059 = (unsigned int) D.14053;
  code_memory_used.4 = code_memory_used.3 - D.14059;
  code_memory_used = code_memory_used.4;
  free (dead);
  <D.13949>:
  if (chunk != 0B) goto <D.13948>; else goto <D.13950>;
  <D.13950>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.14063;
  long int D.14064;
  long int D.14065;
  struct GHashTable * valloc_freelists.5;
  const void * size.6;
  unsigned int D.14074;
  void * size.7;
  _Bool D.14078;
  long int D.14079;
  long int D.14080;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14061>; else goto <D.14062>;
    <D.14061>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14062>:
    D.14063 = ret != 0;
    D.14064 = (long int) D.14063;
    D.14065 = __builtin_expect (D.14064, 0);
    if (D.14065 != 0) goto <D.14066>; else goto <D.14067>;
    <D.14066>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.14067>:
  }
  valloc_freelists.5 = valloc_freelists;
  size.6 = (const void *) size;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.5, size.6);
  if (freelist == 0B) goto <D.14070>; else goto <D.14073>;
  <D.14073>:
  D.14074 = monoeg_g_slist_length (freelist);
  if (D.14074 <= 15) goto <D.14070>; else goto <D.14071>;
  <D.14070>:
  freelist = monoeg_g_slist_prepend (freelist, ptr);
  valloc_freelists.5 = valloc_freelists;
  size.7 = (void *) size;
  monoeg_g_hash_table_insert_replace (valloc_freelists.5, size.7, freelist, 0);
  goto <D.14072>;
  <D.14071>:
  mono_vfree (ptr, size);
  <D.14072>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14076>; else goto <D.14077>;
    <D.14076>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14077>:
    D.14078 = ret != 0;
    D.14079 = (long int) D.14078;
    D.14080 = __builtin_expect (D.14079, 0);
    if (D.14080 != 0) goto <D.14081>; else goto <D.14082>;
    <D.14081>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.14082>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  char * D.14083;
  int D.14084;
  unsigned int D.14085;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 42;
  chunk = cman->current;
  goto <D.13960>;
  <D.13959>:
  D.14083 = chunk->data;
  D.14084 = chunk->size;
  D.14085 = (unsigned int) D.14084;
  memset (D.14083, fill_value, D.14085);
  chunk = chunk->next;
  <D.13960>:
  if (chunk != 0B) goto <D.13959>; else goto <D.13961>;
  <D.13961>:
  chunk = cman->full;
  goto <D.13963>;
  <D.13962>:
  D.14083 = chunk->data;
  D.14084 = chunk->size;
  D.14085 = (unsigned int) D.14084;
  memset (D.14083, fill_value, D.14085);
  chunk = chunk->next;
  <D.13963>:
  if (chunk != 0B) goto <D.13962>; else goto <D.13964>;
  <D.13964>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14088;
  int D.14093;
  void * D.14095;
  unsigned int D.14096;

  D.14088 = __builtin_constant_p (__len);
  if (D.14088 != 0) goto <D.14089>; else goto <D.14090>;
  <D.14089>:
  if (__len == 0) goto <D.14091>; else goto <D.14092>;
  <D.14091>:
  D.14093 = __builtin_constant_p (__ch);
  if (D.14093 == 0) goto <D.14086>; else goto <D.14094>;
  <D.14094>:
  if (__ch != 0) goto <D.14086>; else goto <D.14087>;
  <D.14086>:
  __warn_memset_zero_len ();
  D.14095 = __dest;
  return D.14095;
  <D.14087>:
  <D.14092>:
  <D.14090>:
  D.14096 = __builtin_object_size (__dest, 0);
  D.14095 = __builtin___memset_chk (__dest, __ch, __len, D.14096);
  return D.14095;
}


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)
{
  char * D.14098;
  int D.14099;
  <unnamed-unsigned:24> D.14100;
  int D.14101;
  int D.14102;
  int D.14105;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.13975>;
  <D.13974>:
  D.14098 = chunk->data;
  D.14099 = chunk->size;
  D.14100 = chunk->bsize;
  D.14101 = (int) D.14100;
  D.14102 = func (D.14098, D.14099, D.14101, user_data);
  if (D.14102 != 0) goto <D.14103>; else goto <D.14104>;
  <D.14103>:
  return;
  <D.14104>:
  chunk = chunk->next;
  <D.13975>:
  if (chunk != 0B) goto <D.13974>; else goto <D.13976>;
  <D.13976>:
  chunk = cman->full;
  goto <D.13978>;
  <D.13977>:
  D.14098 = chunk->data;
  D.14099 = chunk->size;
  D.14100 = chunk->bsize;
  D.14101 = (int) D.14100;
  D.14105 = func (D.14098, D.14099, D.14101, user_data);
  if (D.14105 != 0) goto <D.14106>; else goto <D.14107>;
  <D.14106>:
  return;
  <D.14107>:
  chunk = chunk->next;
  <D.13978>:
  if (chunk != 0B) goto <D.13977>; else goto <D.13979>;
  <D.13979>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.14109;
  int D.14110;
  _Bool D.14111;
  long int D.14112;
  long int D.14113;
  _Bool D.14116;
  long int D.14117;
  long int D.14118;
  int D.14121;
  long unsigned int D.14124;
  long unsigned int D.14125;
  long unsigned int D.14126;
  long unsigned int size.8;
  long unsigned int D.14128;
  struct CodeChunk * D.14129;
  struct CodeChunk * D.14132;
  void * D.14135;
  int D.14136;
  int D.14137;
  int D.14138;
  int D.14139;
  int D.14140;
  int D.14141;
  char * D.14144;
  unsigned int D.14145;
  unsigned int D.14146;
  unsigned int D.14147;
  unsigned int D.14148;
  unsigned int D.14149;
  unsigned int D.14150;
  int ptr.9;
  int D.14152;
  int D.14153;
  int D.14154;
  int D.14155;
  struct CodeChunk * D.14160;
  struct CodeChunk * D.14162;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.14109 = alignment + -1;
  align_mask = (guint32) D.14109;
  D.14110 = cman->read_only;
  D.14111 = D.14110 != 0;
  D.14112 = (long int) D.14111;
  D.14113 = __builtin_expect (D.14112, 0);
  if (D.14113 != 0) goto <D.14114>; else goto <D.14115>;
  <D.14114>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.14115>:
  D.14116 = alignment > 8;
  D.14117 = (long int) D.14116;
  D.14118 = __builtin_expect (D.14117, 0);
  if (D.14118 != 0) goto <D.14119>; else goto <D.14120>;
  <D.14119>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.14120>:
  D.14121 = cman->dynamic;
  if (D.14121 != 0) goto <D.14122>; else goto <D.14123>;
  <D.14122>:
  D.14124 = mono_stats.dynamic_code_alloc_count;
  D.14125 = D.14124 + 1;
  mono_stats.dynamic_code_alloc_count = D.14125;
  D.14126 = mono_stats.dynamic_code_bytes_count;
  size.8 = (long unsigned int) size;
  D.14128 = D.14126 + size.8;
  mono_stats.dynamic_code_bytes_count = D.14128;
  <D.14123>:
  D.14129 = cman->current;
  if (D.14129 == 0B) goto <D.14130>; else goto <D.14131>;
  <D.14130>:
  D.14121 = cman->dynamic;
  D.14132 = new_codechunk (D.14121, size);
  cman->current = D.14132;
  D.14129 = cman->current;
  if (D.14129 == 0B) goto <D.14133>; else goto <D.14134>;
  <D.14133>:
  D.14135 = 0B;
  return D.14135;
  <D.14134>:
  <D.14131>:
  chunk = cman->current;
  goto <D.14001>;
  <D.14000>:
  D.14136 = chunk->pos;
  D.14109 = alignment + -1;
  D.14137 = D.14136 + D.14109;
  D.14138 = -alignment;
  D.14139 = D.14137 & D.14138;
  D.14140 = D.14139 + size;
  D.14141 = chunk->size;
  if (D.14140 <= D.14141) goto <D.14142>; else goto <D.14143>;
  <D.14142>:
  D.14136 = chunk->pos;
  D.14109 = alignment + -1;
  D.14137 = D.14136 + D.14109;
  D.14138 = -alignment;
  D.14139 = D.14137 & D.14138;
  chunk->pos = D.14139;
  D.14144 = chunk->data;
  D.14145 = (unsigned int) D.14144;
  D.14146 = D.14145 + align_mask;
  D.14147 = ~align_mask;
  D.14148 = D.14146 & D.14147;
  D.14136 = chunk->pos;
  D.14149 = (unsigned int) D.14136;
  D.14150 = D.14148 + D.14149;
  ptr = (void *) D.14150;
  ptr.9 = (int) ptr;
  D.14144 = chunk->data;
  D.14152 = (int) D.14144;
  D.14153 = ptr.9 - D.14152;
  D.14154 = D.14153 + size;
  chunk->pos = D.14154;
  D.14135 = ptr;
  return D.14135;
  <D.14143>:
  chunk = chunk->next;
  <D.14001>:
  if (chunk != 0B) goto <D.14000>; else goto <D.14002>;
  <D.14002>:
  prev = 0B;
  chunk = cman->current;
  goto <D.14006>;
  <D.14005>:
  D.14136 = chunk->pos;
  D.14155 = D.14136 + 31;
  D.14141 = chunk->size;
  if (D.14155 < D.14141) goto <D.14156>; else goto <D.14157>;
  <D.14156>:
  // predicted unlikely by continue predictor.
  goto <D.14003>;
  <D.14157>:
  if (prev != 0B) goto <D.14158>; else goto <D.14159>;
  <D.14158>:
  D.14160 = chunk->next;
  prev->next = D.14160;
  goto <D.14161>;
  <D.14159>:
  D.14160 = chunk->next;
  cman->current = D.14160;
  <D.14161>:
  D.14162 = cman->full;
  chunk->next = D.14162;
  cman->full = chunk;
  goto <D.14004>;
  <D.14003>:
  prev = chunk;
  chunk = chunk->next;
  <D.14006>:
  if (chunk != 0B) goto <D.14005>; else goto <D.14004>;
  <D.14004>:
  D.14121 = cman->dynamic;
  chunk = new_codechunk (D.14121, size);
  if (chunk == 0B) goto <D.14163>; else goto <D.14164>;
  <D.14163>:
  D.14135 = 0B;
  return D.14135;
  <D.14164>:
  D.14129 = cman->current;
  chunk->next = D.14129;
  cman->current = chunk;
  D.14136 = chunk->pos;
  D.14109 = alignment + -1;
  D.14137 = D.14136 + D.14109;
  D.14138 = -alignment;
  D.14139 = D.14137 & D.14138;
  chunk->pos = D.14139;
  D.14144 = chunk->data;
  D.14145 = (unsigned int) D.14144;
  D.14146 = D.14145 + align_mask;
  D.14147 = ~align_mask;
  D.14148 = D.14146 & D.14147;
  D.14136 = chunk->pos;
  D.14149 = (unsigned int) D.14136;
  D.14150 = D.14148 + D.14149;
  ptr = (void *) D.14150;
  ptr.9 = (int) ptr;
  D.14144 = chunk->data;
  D.14152 = (int) D.14144;
  D.14153 = ptr.9 - D.14152;
  D.14154 = D.14153 + size;
  chunk->pos = D.14154;
  D.14135 = ptr;
  return D.14135;
}


new_codechunk (int dynamic, int size)
{
  int D.14172;
  int D.14173;
  int D.14176;
  unsigned int D.14177;
  struct CodeChunk * D.14180;
  unsigned int chunk_size.10;
  unsigned int chunk_size.11;
  unsigned char D.14193;
  unsigned int bsize.12;
  <unnamed-unsigned:24> D.14195;
  char * D.14196;
  int D.14197;
  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.14166>; else goto <D.14167>;
  <D.14166>:
  chunk_size = size;
  flags = 1;
  goto <D.14168>;
  <D.14167>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.14169>; else goto <D.14170>;
  <D.14169>:
  chunk_size = minsize;
  goto <D.14171>;
  <D.14170>:
  chunk_size = size;
  D.14172 = pagesize + -1;
  chunk_size = D.14172 + chunk_size;
  D.14173 = -pagesize;
  chunk_size = D.14173 & chunk_size;
  <D.14171>:
  <D.14168>:
  if (flags == 1) goto <D.14174>; else goto <D.14175>;
  <D.14174>:
  D.14176 = chunk_size + 7;
  D.14177 = (unsigned int) D.14176;
  ptr = dlmemalign (8, D.14177);
  if (ptr == 0B) goto <D.14178>; else goto <D.14179>;
  <D.14178>:
  D.14180 = 0B;
  return D.14180;
  <D.14179>:
  goto <D.14181>;
  <D.14175>:
  chunk_size.10 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.10);
  if (ptr == 0B) goto <D.14183>; else goto <D.14184>;
  <D.14183>:
  D.14180 = 0B;
  return D.14180;
  <D.14184>:
  <D.14181>:
  if (flags == 1) goto <D.14185>; else goto <D.14186>;
  <D.14185>:
  <D.14186>:
  chunk = malloc (20);
  if (chunk == 0B) goto <D.14187>; else goto <D.14188>;
  <D.14187>:
  if (flags == 1) goto <D.14189>; else goto <D.14190>;
  <D.14189>:
  dlfree (ptr);
  goto <D.14191>;
  <D.14190>:
  chunk_size.11 = (unsigned int) chunk_size;
  mono_vfree (ptr, chunk_size.11);
  <D.14191>:
  D.14180 = 0B;
  return D.14180;
  <D.14188>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.14193 = (unsigned char) flags;
  chunk->flags = D.14193;
  chunk->pos = bsize;
  bsize.12 = (unsigned int) bsize;
  D.14195 = (<unnamed-unsigned:24>) bsize.12;
  chunk->bsize = D.14195;
  D.14196 = chunk->data;
  D.14197 = chunk->size;
  mono_profiler_code_chunk_new (D.14196, D.14197);
  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.14180 = chunk;
  return D.14180;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.16;
  struct GHashTable * valloc_freelists.17;
  _Bool D.14208;
  long int D.14209;
  long int D.14210;
  const void * size.18;
  void * size.19;
  unsigned int D.14218;
  _Bool D.14221;
  long int D.14222;
  long int D.14223;
  void * D.14226;
  void * ptr;
  struct GSList * freelist;

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

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14206>; else goto <D.14207>;
    <D.14206>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14207>:
    D.14208 = ret != 0;
    D.14209 = (long int) D.14208;
    D.14210 = __builtin_expect (D.14209, 0);
    if (D.14210 != 0) goto <D.14211>; else goto <D.14212>;
    <D.14211>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.14212>:
  }
  valloc_freelists.16 = valloc_freelists;
  size.18 = (const void *) size;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.16, size.18);
  if (freelist != 0B) goto <D.14214>; else goto <D.14215>;
  <D.14214>:
  ptr = freelist->data;
  memset (ptr, 0, size);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  valloc_freelists.16 = valloc_freelists;
  size.19 = (void *) size;
  monoeg_g_hash_table_insert_replace (valloc_freelists.16, size.19, freelist, 0);
  goto <D.14217>;
  <D.14215>:
  D.14218 = size + 7;
  ptr = mono_valloc (0B, D.14218, 7);
  <D.14217>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14219>; else goto <D.14220>;
    <D.14219>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14220>:
    D.14221 = ret != 0;
    D.14222 = (long int) D.14221;
    D.14223 = __builtin_expect (D.14222, 0);
    if (D.14223 != 0) goto <D.14224>; else goto <D.14225>;
    <D.14224>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.14225>:
  }
  D.14226 = ptr;
  return D.14226;
}


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

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


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.14230;
  long int D.14231;
  long int D.14232;
  struct CodeChunk * D.14235;
  char * D.14240;
  int D.14241;
  sizetype D.14242;
  sizetype size.20;
  sizetype D.14244;
  char * D.14245;
  int D.14248;
  int D.14249;

  D.14230 = newsize > size;
  D.14231 = (long int) D.14230;
  D.14232 = __builtin_expect (D.14231, 0);
  if (D.14232 != 0) goto <D.14233>; else goto <D.14234>;
  <D.14233>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 702, "newsize <= size");
  <D.14234>:
  D.14235 = cman->current;
  if (D.14235 != 0B) goto <D.14236>; else goto <D.14237>;
  <D.14236>:
  if (size != newsize) goto <D.14238>; else goto <D.14239>;
  <D.14238>:
  D.14235 = cman->current;
  D.14240 = D.14235->data;
  D.14235 = cman->current;
  D.14241 = D.14235->pos;
  D.14242 = (sizetype) D.14241;
  size.20 = (sizetype) size;
  D.14244 = D.14242 - size.20;
  D.14245 = D.14240 + D.14244;
  if (D.14245 == data) goto <D.14246>; else goto <D.14247>;
  <D.14246>:
  D.14235 = cman->current;
  D.14235 = cman->current;
  D.14241 = D.14235->pos;
  D.14248 = newsize - size;
  D.14249 = D.14241 + D.14248;
  D.14235->pos = D.14249;
  <D.14247>:
  <D.14239>:
  <D.14237>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.14250;
  unsigned int D.14251;
  int D.14252;
  unsigned int D.14253;
  int used.21;
  int D.14257;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.14025>;
  <D.14024>:
  D.14250 = chunk->size;
  D.14251 = (unsigned int) D.14250;
  size = D.14251 + size;
  D.14252 = chunk->pos;
  D.14253 = (unsigned int) D.14252;
  used = D.14253 + used;
  chunk = chunk->next;
  <D.14025>:
  if (chunk != 0B) goto <D.14024>; else goto <D.14026>;
  <D.14026>:
  chunk = cman->full;
  goto <D.14028>;
  <D.14027>:
  D.14250 = chunk->size;
  D.14251 = (unsigned int) D.14250;
  size = D.14251 + size;
  D.14252 = chunk->pos;
  D.14253 = (unsigned int) D.14252;
  used = D.14253 + used;
  chunk = chunk->next;
  <D.14028>:
  if (chunk != 0B) goto <D.14027>; else goto <D.14029>;
  <D.14029>:
  if (used_size != 0B) goto <D.14254>; else goto <D.14255>;
  <D.14254>:
  used.21 = (int) used;
  *used_size = used.21;
  <D.14255>:
  D.14257 = (int) size;
  return D.14257;
}