mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


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

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.16616>; else goto <D.16617>;
      <D.16616>:
      return;
      <D.16617>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.16510>;
      <D.16509>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.16507>;
        <D.16506>:
        D.16618 = l->data;
        key.1 = key;
        key.2 = (unsigned int) key.1;
        mono_vfree (D.16618, key.2);
        l = l->next;
        <D.16507>:
        if (l != 0B) goto <D.16506>; else goto <D.16508>;
        <D.16508>:
        monoeg_g_slist_free (freelist);
      }
      <D.16510>:
      D.16621 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.16621 != 0) goto <D.16509>; else goto <D.16511>;
      <D.16511>:
      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.16627;
  struct MonoCodeManager * cman;

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


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

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


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.16631;
  struct CodeChunk * D.16632;

  D.16631 = cman->full;
  free_chunklist (D.16631);
  D.16632 = cman->current;
  free_chunklist (D.16632);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.16633;
  unsigned char D.16634;
  int D.16637;
  unsigned int D.16638;
  unsigned int code_memory_used.3;
  unsigned int D.16643;
  unsigned int code_memory_used.4;
  struct CodeChunk * dead;

  goto <D.16531>;
  <D.16530>:
  dead = chunk;
  D.16633 = dead->data;
  mono_profiler_code_chunk_destroy (D.16633);
  chunk = chunk->next;
  D.16634 = dead->flags;
  if (D.16634 == 0) goto <D.16635>; else goto <D.16636>;
  <D.16635>:
  D.16633 = dead->data;
  D.16637 = dead->size;
  D.16638 = (unsigned int) D.16637;
  codechunk_vfree (D.16633, D.16638);
  goto <D.16639>;
  <D.16636>:
  D.16634 = dead->flags;
  if (D.16634 == 1) goto <D.16640>; else goto <D.16641>;
  <D.16640>:
  D.16633 = dead->data;
  dlfree (D.16633);
  <D.16641>:
  <D.16639>:
  code_memory_used.3 = code_memory_used;
  D.16637 = dead->size;
  D.16643 = (unsigned int) D.16637;
  code_memory_used.4 = code_memory_used.3 - D.16643;
  code_memory_used = code_memory_used.4;
  free (dead);
  <D.16531>:
  if (chunk != 0B) goto <D.16530>; else goto <D.16532>;
  <D.16532>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.16647;
  long int D.16648;
  long int D.16649;
  struct GHashTable * valloc_freelists.5;
  const void * size.6;
  unsigned int D.16658;
  void * size.7;
  _Bool D.16662;
  long int D.16663;
  long int D.16664;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.16645>; else goto <D.16646>;
    <D.16645>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.16646>:
    D.16647 = ret != 0;
    D.16648 = (long int) D.16647;
    D.16649 = __builtin_expect (D.16648, 0);
    if (D.16649 != 0) goto <D.16650>; else goto <D.16651>;
    <D.16650>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.16651>:
  }
  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.16654>; else goto <D.16657>;
  <D.16657>:
  D.16658 = monoeg_g_slist_length (freelist);
  if (D.16658 <= 15) goto <D.16654>; else goto <D.16655>;
  <D.16654>:
  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.16656>;
  <D.16655>:
  mono_vfree (ptr, size);
  <D.16656>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.16660>; else goto <D.16661>;
    <D.16660>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.16661>:
    D.16662 = ret != 0;
    D.16663 = (long int) D.16662;
    D.16664 = __builtin_expect (D.16663, 0);
    if (D.16664 != 0) goto <D.16665>; else goto <D.16666>;
    <D.16665>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.16666>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  char * D.16667;
  int D.16668;
  unsigned int D.16669;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 42;
  chunk = cman->current;
  goto <D.16542>;
  <D.16541>:
  D.16667 = chunk->data;
  D.16668 = chunk->size;
  D.16669 = (unsigned int) D.16668;
  memset (D.16667, fill_value, D.16669);
  chunk = chunk->next;
  <D.16542>:
  if (chunk != 0B) goto <D.16541>; else goto <D.16543>;
  <D.16543>:
  chunk = cman->full;
  goto <D.16545>;
  <D.16544>:
  D.16667 = chunk->data;
  D.16668 = chunk->size;
  D.16669 = (unsigned int) D.16668;
  memset (D.16667, fill_value, D.16669);
  chunk = chunk->next;
  <D.16545>:
  if (chunk != 0B) goto <D.16544>; else goto <D.16546>;
  <D.16546>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.16672;
  int D.16677;
  void * D.16679;
  unsigned int D.16680;

  D.16672 = __builtin_constant_p (__len);
  if (D.16672 != 0) goto <D.16673>; else goto <D.16674>;
  <D.16673>:
  if (__len == 0) goto <D.16675>; else goto <D.16676>;
  <D.16675>:
  D.16677 = __builtin_constant_p (__ch);
  if (D.16677 == 0) goto <D.16670>; else goto <D.16678>;
  <D.16678>:
  if (__ch != 0) goto <D.16670>; else goto <D.16671>;
  <D.16670>:
  __warn_memset_zero_len ();
  D.16679 = __dest;
  return D.16679;
  <D.16671>:
  <D.16676>:
  <D.16674>:
  D.16680 = __builtin_object_size (__dest, 0);
  D.16679 = __builtin___memset_chk (__dest, __ch, __len, D.16680);
  return D.16679;
}


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.16682;
  int D.16683;
  <unnamed-unsigned:24> D.16684;
  int D.16685;
  int D.16686;
  int D.16689;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.16557>;
  <D.16556>:
  D.16682 = chunk->data;
  D.16683 = chunk->size;
  D.16684 = chunk->bsize;
  D.16685 = (int) D.16684;
  D.16686 = func (D.16682, D.16683, D.16685, user_data);
  if (D.16686 != 0) goto <D.16687>; else goto <D.16688>;
  <D.16687>:
  return;
  <D.16688>:
  chunk = chunk->next;
  <D.16557>:
  if (chunk != 0B) goto <D.16556>; else goto <D.16558>;
  <D.16558>:
  chunk = cman->full;
  goto <D.16560>;
  <D.16559>:
  D.16682 = chunk->data;
  D.16683 = chunk->size;
  D.16684 = chunk->bsize;
  D.16685 = (int) D.16684;
  D.16689 = func (D.16682, D.16683, D.16685, user_data);
  if (D.16689 != 0) goto <D.16690>; else goto <D.16691>;
  <D.16690>:
  return;
  <D.16691>:
  chunk = chunk->next;
  <D.16560>:
  if (chunk != 0B) goto <D.16559>; else goto <D.16561>;
  <D.16561>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.16693;
  int D.16694;
  _Bool D.16695;
  long int D.16696;
  long int D.16697;
  _Bool D.16700;
  long int D.16701;
  long int D.16702;
  int D.16705;
  long unsigned int D.16708;
  long unsigned int D.16709;
  long unsigned int D.16710;
  long unsigned int size.8;
  long unsigned int D.16712;
  struct CodeChunk * D.16713;
  struct CodeChunk * D.16716;
  void * D.16719;
  int D.16720;
  int D.16721;
  int D.16722;
  int D.16723;
  int D.16724;
  int D.16725;
  char * D.16728;
  unsigned int D.16729;
  unsigned int D.16730;
  unsigned int D.16731;
  unsigned int D.16732;
  unsigned int D.16733;
  unsigned int D.16734;
  int ptr.9;
  int D.16736;
  int D.16737;
  int D.16738;
  int D.16739;
  struct CodeChunk * D.16744;
  struct CodeChunk * D.16746;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.16693 = alignment + -1;
  align_mask = (guint32) D.16693;
  D.16694 = cman->read_only;
  D.16695 = D.16694 != 0;
  D.16696 = (long int) D.16695;
  D.16697 = __builtin_expect (D.16696, 0);
  if (D.16697 != 0) goto <D.16698>; else goto <D.16699>;
  <D.16698>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.16699>:
  D.16700 = alignment > 8;
  D.16701 = (long int) D.16700;
  D.16702 = __builtin_expect (D.16701, 0);
  if (D.16702 != 0) goto <D.16703>; else goto <D.16704>;
  <D.16703>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.16704>:
  D.16705 = cman->dynamic;
  if (D.16705 != 0) goto <D.16706>; else goto <D.16707>;
  <D.16706>:
  D.16708 = mono_stats.dynamic_code_alloc_count;
  D.16709 = D.16708 + 1;
  mono_stats.dynamic_code_alloc_count = D.16709;
  D.16710 = mono_stats.dynamic_code_bytes_count;
  size.8 = (long unsigned int) size;
  D.16712 = D.16710 + size.8;
  mono_stats.dynamic_code_bytes_count = D.16712;
  <D.16707>:
  D.16713 = cman->current;
  if (D.16713 == 0B) goto <D.16714>; else goto <D.16715>;
  <D.16714>:
  D.16705 = cman->dynamic;
  D.16716 = new_codechunk (D.16705, size);
  cman->current = D.16716;
  D.16713 = cman->current;
  if (D.16713 == 0B) goto <D.16717>; else goto <D.16718>;
  <D.16717>:
  D.16719 = 0B;
  return D.16719;
  <D.16718>:
  <D.16715>:
  chunk = cman->current;
  goto <D.16583>;
  <D.16582>:
  D.16720 = chunk->pos;
  D.16693 = alignment + -1;
  D.16721 = D.16720 + D.16693;
  D.16722 = -alignment;
  D.16723 = D.16721 & D.16722;
  D.16724 = D.16723 + size;
  D.16725 = chunk->size;
  if (D.16724 <= D.16725) goto <D.16726>; else goto <D.16727>;
  <D.16726>:
  D.16720 = chunk->pos;
  D.16693 = alignment + -1;
  D.16721 = D.16720 + D.16693;
  D.16722 = -alignment;
  D.16723 = D.16721 & D.16722;
  chunk->pos = D.16723;
  D.16728 = chunk->data;
  D.16729 = (unsigned int) D.16728;
  D.16730 = D.16729 + align_mask;
  D.16731 = ~align_mask;
  D.16732 = D.16730 & D.16731;
  D.16720 = chunk->pos;
  D.16733 = (unsigned int) D.16720;
  D.16734 = D.16732 + D.16733;
  ptr = (void *) D.16734;
  ptr.9 = (int) ptr;
  D.16728 = chunk->data;
  D.16736 = (int) D.16728;
  D.16737 = ptr.9 - D.16736;
  D.16738 = D.16737 + size;
  chunk->pos = D.16738;
  D.16719 = ptr;
  return D.16719;
  <D.16727>:
  chunk = chunk->next;
  <D.16583>:
  if (chunk != 0B) goto <D.16582>; else goto <D.16584>;
  <D.16584>:
  prev = 0B;
  chunk = cman->current;
  goto <D.16588>;
  <D.16587>:
  D.16720 = chunk->pos;
  D.16739 = D.16720 + 31;
  D.16725 = chunk->size;
  if (D.16739 < D.16725) goto <D.16740>; else goto <D.16741>;
  <D.16740>:
  // predicted unlikely by continue predictor.
  goto <D.16585>;
  <D.16741>:
  if (prev != 0B) goto <D.16742>; else goto <D.16743>;
  <D.16742>:
  D.16744 = chunk->next;
  prev->next = D.16744;
  goto <D.16745>;
  <D.16743>:
  D.16744 = chunk->next;
  cman->current = D.16744;
  <D.16745>:
  D.16746 = cman->full;
  chunk->next = D.16746;
  cman->full = chunk;
  goto <D.16586>;
  <D.16585>:
  prev = chunk;
  chunk = chunk->next;
  <D.16588>:
  if (chunk != 0B) goto <D.16587>; else goto <D.16586>;
  <D.16586>:
  D.16705 = cman->dynamic;
  chunk = new_codechunk (D.16705, size);
  if (chunk == 0B) goto <D.16747>; else goto <D.16748>;
  <D.16747>:
  D.16719 = 0B;
  return D.16719;
  <D.16748>:
  D.16713 = cman->current;
  chunk->next = D.16713;
  cman->current = chunk;
  D.16720 = chunk->pos;
  D.16693 = alignment + -1;
  D.16721 = D.16720 + D.16693;
  D.16722 = -alignment;
  D.16723 = D.16721 & D.16722;
  chunk->pos = D.16723;
  D.16728 = chunk->data;
  D.16729 = (unsigned int) D.16728;
  D.16730 = D.16729 + align_mask;
  D.16731 = ~align_mask;
  D.16732 = D.16730 & D.16731;
  D.16720 = chunk->pos;
  D.16733 = (unsigned int) D.16720;
  D.16734 = D.16732 + D.16733;
  ptr = (void *) D.16734;
  ptr.9 = (int) ptr;
  D.16728 = chunk->data;
  D.16736 = (int) D.16728;
  D.16737 = ptr.9 - D.16736;
  D.16738 = D.16737 + size;
  chunk->pos = D.16738;
  D.16719 = ptr;
  return D.16719;
}


new_codechunk (int dynamic, int size)
{
  int D.16756;
  int D.16757;
  int D.16760;
  int D.16765;
  unsigned int D.16766;
  struct CodeChunk * D.16769;
  unsigned int chunk_size.10;
  unsigned int bsize.11;
  unsigned int chunk_size.12;
  unsigned char D.16783;
  unsigned int bsize.13;
  <unnamed-unsigned:24> D.16785;
  char * D.16786;
  int D.16787;
  unsigned int code_memory_used.14;
  unsigned int chunk_size.15;
  unsigned int code_memory_used.16;
  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.16750>; else goto <D.16751>;
  <D.16750>:
  chunk_size = size;
  flags = 1;
  goto <D.16752>;
  <D.16751>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.16753>; else goto <D.16754>;
  <D.16753>:
  chunk_size = minsize;
  goto <D.16755>;
  <D.16754>:
  chunk_size = size;
  D.16756 = pagesize + -1;
  chunk_size = D.16756 + chunk_size;
  D.16757 = -pagesize;
  chunk_size = D.16757 & chunk_size;
  <D.16755>:
  <D.16752>:
  bsize = chunk_size / 8;
  if (bsize <= 31) goto <D.16758>; else goto <D.16759>;
  <D.16758>:
  bsize = 32;
  <D.16759>:
  bsize = bsize + 7;
  bsize = bsize & -8;
  D.16760 = chunk_size - size;
  if (D.16760 < bsize) goto <D.16761>; else goto <D.16762>;
  <D.16761>:
  chunk_size = size + bsize;
  D.16756 = pagesize + -1;
  chunk_size = D.16756 + chunk_size;
  D.16757 = -pagesize;
  chunk_size = D.16757 & chunk_size;
  <D.16762>:
  if (flags == 1) goto <D.16763>; else goto <D.16764>;
  <D.16763>:
  D.16765 = chunk_size + 7;
  D.16766 = (unsigned int) D.16765;
  ptr = dlmemalign (8, D.16766);
  if (ptr == 0B) goto <D.16767>; else goto <D.16768>;
  <D.16767>:
  D.16769 = 0B;
  return D.16769;
  <D.16768>:
  goto <D.16770>;
  <D.16764>:
  chunk_size.10 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.10);
  if (ptr == 0B) goto <D.16772>; else goto <D.16773>;
  <D.16772>:
  D.16769 = 0B;
  return D.16769;
  <D.16773>:
  <D.16770>:
  if (flags == 1) goto <D.16774>; else goto <D.16775>;
  <D.16774>:
  bsize.11 = (unsigned int) bsize;
  memset (ptr, 0, bsize.11);
  <D.16775>:
  chunk = malloc (20);
  if (chunk == 0B) goto <D.16777>; else goto <D.16778>;
  <D.16777>:
  if (flags == 1) goto <D.16779>; else goto <D.16780>;
  <D.16779>:
  dlfree (ptr);
  goto <D.16781>;
  <D.16780>:
  chunk_size.12 = (unsigned int) chunk_size;
  mono_vfree (ptr, chunk_size.12);
  <D.16781>:
  D.16769 = 0B;
  return D.16769;
  <D.16778>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.16783 = (unsigned char) flags;
  chunk->flags = D.16783;
  chunk->pos = bsize;
  bsize.13 = (unsigned int) bsize;
  D.16785 = (<unnamed-unsigned:24>) bsize.13;
  chunk->bsize = D.16785;
  D.16786 = chunk->data;
  D.16787 = chunk->size;
  mono_profiler_code_chunk_new (D.16786, D.16787);
  code_memory_used.14 = code_memory_used;
  chunk_size.15 = (unsigned int) chunk_size;
  code_memory_used.16 = code_memory_used.14 + chunk_size.15;
  code_memory_used = code_memory_used.16;
  code_memory_used.14 = code_memory_used;
  mono_runtime_resource_check_limit (0, code_memory_used.14);
  D.16769 = chunk;
  return D.16769;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.17;
  struct GHashTable * valloc_freelists.18;
  _Bool D.16798;
  long int D.16799;
  long int D.16800;
  const void * size.19;
  void * size.20;
  unsigned int D.16808;
  _Bool D.16811;
  long int D.16812;
  long int D.16813;
  void * D.16816;
  void * ptr;
  struct GSList * freelist;

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

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.16796>; else goto <D.16797>;
    <D.16796>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.16797>:
    D.16798 = ret != 0;
    D.16799 = (long int) D.16798;
    D.16800 = __builtin_expect (D.16799, 0);
    if (D.16800 != 0) goto <D.16801>; else goto <D.16802>;
    <D.16801>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.16802>:
  }
  valloc_freelists.17 = valloc_freelists;
  size.19 = (const void *) size;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.17, size.19);
  if (freelist != 0B) goto <D.16804>; else goto <D.16805>;
  <D.16804>:
  ptr = freelist->data;
  memset (ptr, 0, size);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  valloc_freelists.17 = valloc_freelists;
  size.20 = (void *) size;
  monoeg_g_hash_table_insert_replace (valloc_freelists.17, size.20, freelist, 0);
  goto <D.16807>;
  <D.16805>:
  D.16808 = size + 7;
  ptr = mono_valloc (0B, D.16808, 7);
  <D.16807>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.16809>; else goto <D.16810>;
    <D.16809>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.16810>:
    D.16811 = ret != 0;
    D.16812 = (long int) D.16811;
    D.16813 = __builtin_expect (D.16812, 0);
    if (D.16813 != 0) goto <D.16814>; else goto <D.16815>;
    <D.16814>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.16815>:
  }
  D.16816 = ptr;
  return D.16816;
}


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

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


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.16820;
  long int D.16821;
  long int D.16822;
  struct CodeChunk * D.16825;
  char * D.16830;
  int D.16831;
  sizetype D.16832;
  sizetype size.21;
  sizetype D.16834;
  char * D.16835;
  int D.16838;
  int D.16839;

  D.16820 = newsize > size;
  D.16821 = (long int) D.16820;
  D.16822 = __builtin_expect (D.16821, 0);
  if (D.16822 != 0) goto <D.16823>; else goto <D.16824>;
  <D.16823>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 702, "newsize <= size");
  <D.16824>:
  D.16825 = cman->current;
  if (D.16825 != 0B) goto <D.16826>; else goto <D.16827>;
  <D.16826>:
  if (size != newsize) goto <D.16828>; else goto <D.16829>;
  <D.16828>:
  D.16825 = cman->current;
  D.16830 = D.16825->data;
  D.16825 = cman->current;
  D.16831 = D.16825->pos;
  D.16832 = (sizetype) D.16831;
  size.21 = (sizetype) size;
  D.16834 = D.16832 - size.21;
  D.16835 = D.16830 + D.16834;
  if (D.16835 == data) goto <D.16836>; else goto <D.16837>;
  <D.16836>:
  D.16825 = cman->current;
  D.16825 = cman->current;
  D.16831 = D.16825->pos;
  D.16838 = newsize - size;
  D.16839 = D.16831 + D.16838;
  D.16825->pos = D.16839;
  <D.16837>:
  <D.16829>:
  <D.16827>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.16840;
  unsigned int D.16841;
  int D.16842;
  unsigned int D.16843;
  int used.22;
  int D.16847;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.16607>;
  <D.16606>:
  D.16840 = chunk->size;
  D.16841 = (unsigned int) D.16840;
  size = D.16841 + size;
  D.16842 = chunk->pos;
  D.16843 = (unsigned int) D.16842;
  used = D.16843 + used;
  chunk = chunk->next;
  <D.16607>:
  if (chunk != 0B) goto <D.16606>; else goto <D.16608>;
  <D.16608>:
  chunk = cman->full;
  goto <D.16610>;
  <D.16609>:
  D.16840 = chunk->size;
  D.16841 = (unsigned int) D.16840;
  size = D.16841 + size;
  D.16842 = chunk->pos;
  D.16843 = (unsigned int) D.16842;
  used = D.16843 + used;
  chunk = chunk->next;
  <D.16610>:
  if (chunk != 0B) goto <D.16609>; else goto <D.16611>;
  <D.16611>:
  if (used_size != 0B) goto <D.16844>; else goto <D.16845>;
  <D.16844>:
  used.22 = (int) used;
  *used_size = used.22;
  <D.16845>:
  D.16847 = (int) size;
  return D.16847;
}