mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


codechunk_cleanup ()
{
  struct GHashTable * valloc_freelists.0;
  void * D.14532;
  void * key.1;
  long int key.2;
  unsigned int D.14535;
  long unsigned int D.14536;
  int D.14537;
  struct GHashTableIter iter;
  void * key;
  void * value;

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.14530>; else goto <D.14531>;
      <D.14530>:
      return;
      <D.14531>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.14426>;
      <D.14425>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.14423>;
        <D.14422>:
        D.14532 = l->data;
        key.1 = key;
        key.2 = (long int) key.1;
        D.14535 = (unsigned int) key.2;
        D.14536 = (long unsigned int) D.14535;
        mono_vfree (D.14532, D.14536);
        l = l->next;
        <D.14423>:
        if (l != 0B) goto <D.14422>; else goto <D.14424>;
        <D.14424>:
        monoeg_g_slist_free (freelist);
      }
      <D.14426>:
      D.14537 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.14537 != 0) goto <D.14425>; else goto <D.14427>;
      <D.14427>:
      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.14543;
  struct MonoCodeManager * cman;

  cman = malloc (24);
  if (cman == 0B) goto <D.14541>; else goto <D.14542>;
  <D.14541>:
  D.14543 = 0B;
  return D.14543;
  <D.14542>:
  cman->current = 0B;
  cman->full = 0B;
  cman->dynamic = 0;
  cman->read_only = 0;
  D.14543 = cman;
  return D.14543;
}


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

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


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.14547;
  struct CodeChunk * D.14548;

  D.14547 = cman->full;
  free_chunklist (D.14547);
  D.14548 = cman->current;
  free_chunklist (D.14548);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.14549;
  unsigned char D.14550;
  int D.14553;
  unsigned int D.14554;
  long unsigned int code_memory_used.3;
  long unsigned int D.14559;
  long unsigned int D.14560;
  struct CodeChunk * dead;

  goto <D.14447>;
  <D.14446>:
  dead = chunk;
  D.14549 = dead->data;
  mono_profiler_code_chunk_destroy (D.14549);
  chunk = chunk->next;
  D.14550 = dead->flags;
  if (D.14550 == 0) goto <D.14551>; else goto <D.14552>;
  <D.14551>:
  D.14549 = dead->data;
  D.14553 = dead->size;
  D.14554 = (unsigned int) D.14553;
  codechunk_vfree (D.14549, D.14554);
  goto <D.14555>;
  <D.14552>:
  D.14550 = dead->flags;
  if (D.14550 == 1) goto <D.14556>; else goto <D.14557>;
  <D.14556>:
  D.14549 = dead->data;
  dlfree (D.14549);
  <D.14557>:
  <D.14555>:
  code_memory_used.3 = code_memory_used;
  D.14553 = dead->size;
  D.14559 = (long unsigned int) D.14553;
  D.14560 = code_memory_used.3 - D.14559;
  code_memory_used = D.14560;
  free (dead);
  <D.14447>:
  if (chunk != 0B) goto <D.14446>; else goto <D.14448>;
  <D.14448>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.14563;
  long int D.14564;
  long int D.14565;
  struct GHashTable * valloc_freelists.4;
  long unsigned int D.14569;
  const void * D.14570;
  unsigned int D.14575;
  void * D.14576;
  long unsigned int D.14577;
  _Bool D.14580;
  long int D.14581;
  long int D.14582;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14561>; else goto <D.14562>;
    <D.14561>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14562>:
    D.14563 = ret != 0;
    D.14564 = (long int) D.14563;
    D.14565 = __builtin_expect (D.14564, 0);
    if (D.14565 != 0) goto <D.14566>; else goto <D.14567>;
    <D.14566>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.14567>:
  }
  valloc_freelists.4 = valloc_freelists;
  D.14569 = (long unsigned int) size;
  D.14570 = (const void *) D.14569;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.4, D.14570);
  if (freelist == 0B) goto <D.14571>; else goto <D.14574>;
  <D.14574>:
  D.14575 = monoeg_g_slist_length (freelist);
  if (D.14575 <= 15) goto <D.14571>; else goto <D.14572>;
  <D.14571>:
  freelist = monoeg_g_slist_prepend (freelist, ptr);
  valloc_freelists.4 = valloc_freelists;
  D.14569 = (long unsigned int) size;
  D.14576 = (void *) D.14569;
  monoeg_g_hash_table_insert_replace (valloc_freelists.4, D.14576, freelist, 0);
  goto <D.14573>;
  <D.14572>:
  D.14577 = (long unsigned int) size;
  mono_vfree (ptr, D.14577);
  <D.14573>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14578>; else goto <D.14579>;
    <D.14578>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14579>:
    D.14580 = ret != 0;
    D.14581 = (long int) D.14580;
    D.14582 = __builtin_expect (D.14581, 0);
    if (D.14582 != 0) goto <D.14583>; else goto <D.14584>;
    <D.14583>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.14584>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  char * D.14585;
  int D.14586;
  long unsigned int D.14587;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 42;
  chunk = cman->current;
  goto <D.14458>;
  <D.14457>:
  D.14585 = chunk->data;
  D.14586 = chunk->size;
  D.14587 = (long unsigned int) D.14586;
  memset (D.14585, fill_value, D.14587);
  chunk = chunk->next;
  <D.14458>:
  if (chunk != 0B) goto <D.14457>; else goto <D.14459>;
  <D.14459>:
  chunk = cman->full;
  goto <D.14461>;
  <D.14460>:
  D.14585 = chunk->data;
  D.14586 = chunk->size;
  D.14587 = (long unsigned int) D.14586;
  memset (D.14585, fill_value, D.14587);
  chunk = chunk->next;
  <D.14461>:
  if (chunk != 0B) goto <D.14460>; else goto <D.14462>;
  <D.14462>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.14588;
  long unsigned int D.14589;

  D.14589 = __builtin_object_size (__dest, 0);
  D.14588 = __builtin___memset_chk (__dest, __ch, __len, D.14589);
  return D.14588;
}


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.14591;
  int D.14592;
  <unnamed-unsigned:24> D.14593;
  int D.14594;
  int D.14595;
  int D.14598;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.14473>;
  <D.14472>:
  D.14591 = chunk->data;
  D.14592 = chunk->size;
  D.14593 = chunk->bsize;
  D.14594 = (int) D.14593;
  D.14595 = func (D.14591, D.14592, D.14594, user_data);
  if (D.14595 != 0) goto <D.14596>; else goto <D.14597>;
  <D.14596>:
  return;
  <D.14597>:
  chunk = chunk->next;
  <D.14473>:
  if (chunk != 0B) goto <D.14472>; else goto <D.14474>;
  <D.14474>:
  chunk = cman->full;
  goto <D.14476>;
  <D.14475>:
  D.14591 = chunk->data;
  D.14592 = chunk->size;
  D.14593 = chunk->bsize;
  D.14594 = (int) D.14593;
  D.14598 = func (D.14591, D.14592, D.14594, user_data);
  if (D.14598 != 0) goto <D.14599>; else goto <D.14600>;
  <D.14599>:
  return;
  <D.14600>:
  chunk = chunk->next;
  <D.14476>:
  if (chunk != 0B) goto <D.14475>; else goto <D.14477>;
  <D.14477>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.14602;
  int D.14603;
  _Bool D.14604;
  long int D.14605;
  long int D.14606;
  _Bool D.14609;
  long int D.14610;
  long int D.14611;
  int D.14614;
  long unsigned int D.14617;
  long unsigned int D.14618;
  long unsigned int D.14619;
  long unsigned int D.14620;
  long unsigned int D.14621;
  struct CodeChunk * D.14622;
  struct CodeChunk * D.14625;
  void * D.14628;
  int D.14629;
  int D.14630;
  int D.14631;
  int D.14632;
  int D.14633;
  int D.14634;
  char * D.14637;
  long unsigned int D.14638;
  long unsigned int D.14639;
  long unsigned int D.14640;
  long unsigned int D.14641;
  long unsigned int D.14642;
  long unsigned int D.14643;
  long unsigned int D.14644;
  long int ptr.5;
  long int D.14646;
  long int D.14647;
  unsigned int D.14648;
  unsigned int size.6;
  unsigned int D.14650;
  int D.14651;
  int D.14652;
  struct CodeChunk * D.14657;
  struct CodeChunk * D.14659;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.14602 = alignment + -1;
  align_mask = (guint32) D.14602;
  D.14603 = cman->read_only;
  D.14604 = D.14603 != 0;
  D.14605 = (long int) D.14604;
  D.14606 = __builtin_expect (D.14605, 0);
  if (D.14606 != 0) goto <D.14607>; else goto <D.14608>;
  <D.14607>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.14608>:
  D.14609 = alignment > 8;
  D.14610 = (long int) D.14609;
  D.14611 = __builtin_expect (D.14610, 0);
  if (D.14611 != 0) goto <D.14612>; else goto <D.14613>;
  <D.14612>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.14613>:
  D.14614 = cman->dynamic;
  if (D.14614 != 0) goto <D.14615>; else goto <D.14616>;
  <D.14615>:
  D.14617 = mono_stats.dynamic_code_alloc_count;
  D.14618 = D.14617 + 1;
  mono_stats.dynamic_code_alloc_count = D.14618;
  D.14619 = mono_stats.dynamic_code_bytes_count;
  D.14620 = (long unsigned int) size;
  D.14621 = D.14619 + D.14620;
  mono_stats.dynamic_code_bytes_count = D.14621;
  <D.14616>:
  D.14622 = cman->current;
  if (D.14622 == 0B) goto <D.14623>; else goto <D.14624>;
  <D.14623>:
  D.14614 = cman->dynamic;
  D.14625 = new_codechunk (D.14614, size);
  cman->current = D.14625;
  D.14622 = cman->current;
  if (D.14622 == 0B) goto <D.14626>; else goto <D.14627>;
  <D.14626>:
  D.14628 = 0B;
  return D.14628;
  <D.14627>:
  <D.14624>:
  chunk = cman->current;
  goto <D.14499>;
  <D.14498>:
  D.14629 = chunk->pos;
  D.14602 = alignment + -1;
  D.14630 = D.14629 + D.14602;
  D.14631 = -alignment;
  D.14632 = D.14630 & D.14631;
  D.14633 = D.14632 + size;
  D.14634 = chunk->size;
  if (D.14633 <= D.14634) goto <D.14635>; else goto <D.14636>;
  <D.14635>:
  D.14629 = chunk->pos;
  D.14602 = alignment + -1;
  D.14630 = D.14629 + D.14602;
  D.14631 = -alignment;
  D.14632 = D.14630 & D.14631;
  chunk->pos = D.14632;
  D.14637 = chunk->data;
  D.14638 = (long unsigned int) D.14637;
  D.14639 = (long unsigned int) align_mask;
  D.14640 = D.14638 + D.14639;
  D.14639 = (long unsigned int) align_mask;
  D.14641 = ~D.14639;
  D.14642 = D.14640 & D.14641;
  D.14629 = chunk->pos;
  D.14643 = (long unsigned int) D.14629;
  D.14644 = D.14642 + D.14643;
  ptr = (void *) D.14644;
  ptr.5 = (long int) ptr;
  D.14637 = chunk->data;
  D.14646 = (long int) D.14637;
  D.14647 = ptr.5 - D.14646;
  D.14648 = (unsigned int) D.14647;
  size.6 = (unsigned int) size;
  D.14650 = D.14648 + size.6;
  D.14651 = (int) D.14650;
  chunk->pos = D.14651;
  D.14628 = ptr;
  return D.14628;
  <D.14636>:
  chunk = chunk->next;
  <D.14499>:
  if (chunk != 0B) goto <D.14498>; else goto <D.14500>;
  <D.14500>:
  prev = 0B;
  chunk = cman->current;
  goto <D.14504>;
  <D.14503>:
  D.14629 = chunk->pos;
  D.14652 = D.14629 + 31;
  D.14634 = chunk->size;
  if (D.14652 < D.14634) goto <D.14653>; else goto <D.14654>;
  <D.14653>:
  // predicted unlikely by continue predictor.
  goto <D.14501>;
  <D.14654>:
  if (prev != 0B) goto <D.14655>; else goto <D.14656>;
  <D.14655>:
  D.14657 = chunk->next;
  prev->next = D.14657;
  goto <D.14658>;
  <D.14656>:
  D.14657 = chunk->next;
  cman->current = D.14657;
  <D.14658>:
  D.14659 = cman->full;
  chunk->next = D.14659;
  cman->full = chunk;
  goto <D.14502>;
  <D.14501>:
  prev = chunk;
  chunk = chunk->next;
  <D.14504>:
  if (chunk != 0B) goto <D.14503>; else goto <D.14502>;
  <D.14502>:
  D.14614 = cman->dynamic;
  chunk = new_codechunk (D.14614, size);
  if (chunk == 0B) goto <D.14660>; else goto <D.14661>;
  <D.14660>:
  D.14628 = 0B;
  return D.14628;
  <D.14661>:
  D.14622 = cman->current;
  chunk->next = D.14622;
  cman->current = chunk;
  D.14629 = chunk->pos;
  D.14602 = alignment + -1;
  D.14630 = D.14629 + D.14602;
  D.14631 = -alignment;
  D.14632 = D.14630 & D.14631;
  chunk->pos = D.14632;
  D.14637 = chunk->data;
  D.14638 = (long unsigned int) D.14637;
  D.14639 = (long unsigned int) align_mask;
  D.14640 = D.14638 + D.14639;
  D.14639 = (long unsigned int) align_mask;
  D.14641 = ~D.14639;
  D.14642 = D.14640 & D.14641;
  D.14629 = chunk->pos;
  D.14643 = (long unsigned int) D.14629;
  D.14644 = D.14642 + D.14643;
  ptr = (void *) D.14644;
  ptr.5 = (long int) ptr;
  D.14637 = chunk->data;
  D.14646 = (long int) D.14637;
  D.14647 = ptr.5 - D.14646;
  D.14648 = (unsigned int) D.14647;
  size.6 = (unsigned int) size;
  D.14650 = D.14648 + size.6;
  D.14651 = (int) D.14650;
  chunk->pos = D.14651;
  D.14628 = ptr;
  return D.14628;
}


new_codechunk (int dynamic, int size)
{
  int D.14669;
  int D.14670;
  int D.14673;
  long unsigned int D.14674;
  struct CodeChunk * D.14677;
  unsigned int chunk_size.7;
  long unsigned int D.14689;
  unsigned char D.14690;
  unsigned int bsize.8;
  <unnamed-unsigned:24> D.14692;
  char * D.14693;
  int D.14694;
  long unsigned int D.14695;
  long unsigned int code_memory_used.9;
  long unsigned int D.14697;
  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.14663>; else goto <D.14664>;
  <D.14663>:
  chunk_size = size;
  flags = 1;
  goto <D.14665>;
  <D.14664>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.14666>; else goto <D.14667>;
  <D.14666>:
  chunk_size = minsize;
  goto <D.14668>;
  <D.14667>:
  chunk_size = size;
  D.14669 = pagesize + -1;
  chunk_size = D.14669 + chunk_size;
  D.14670 = -pagesize;
  chunk_size = D.14670 & chunk_size;
  <D.14668>:
  <D.14665>:
  if (flags == 1) goto <D.14671>; else goto <D.14672>;
  <D.14671>:
  D.14673 = chunk_size + 7;
  D.14674 = (long unsigned int) D.14673;
  ptr = dlmemalign (8, D.14674);
  if (ptr == 0B) goto <D.14675>; else goto <D.14676>;
  <D.14675>:
  D.14677 = 0B;
  return D.14677;
  <D.14676>:
  goto <D.14678>;
  <D.14672>:
  chunk_size.7 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.7);
  if (ptr == 0B) goto <D.14680>; else goto <D.14681>;
  <D.14680>:
  D.14677 = 0B;
  return D.14677;
  <D.14681>:
  <D.14678>:
  if (flags == 1) goto <D.14682>; else goto <D.14683>;
  <D.14682>:
  <D.14683>:
  chunk = malloc (32);
  if (chunk == 0B) goto <D.14684>; else goto <D.14685>;
  <D.14684>:
  if (flags == 1) goto <D.14686>; else goto <D.14687>;
  <D.14686>:
  dlfree (ptr);
  goto <D.14688>;
  <D.14687>:
  D.14689 = (long unsigned int) chunk_size;
  mono_vfree (ptr, D.14689);
  <D.14688>:
  D.14677 = 0B;
  return D.14677;
  <D.14685>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.14690 = (unsigned char) flags;
  chunk->flags = D.14690;
  chunk->pos = bsize;
  bsize.8 = (unsigned int) bsize;
  D.14692 = (<unnamed-unsigned:24>) bsize.8;
  chunk->bsize = D.14692;
  D.14693 = chunk->data;
  D.14694 = chunk->size;
  mono_profiler_code_chunk_new (D.14693, D.14694);
  D.14695 = (long unsigned int) chunk_size;
  code_memory_used.9 = code_memory_used;
  D.14697 = D.14695 + code_memory_used.9;
  code_memory_used = D.14697;
  code_memory_used.9 = code_memory_used;
  mono_runtime_resource_check_limit (0, code_memory_used.9);
  D.14677 = chunk;
  return D.14677;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.10;
  struct GHashTable * D.14702;
  _Bool D.14705;
  long int D.14706;
  long int D.14707;
  long unsigned int D.14710;
  const void * D.14711;
  long unsigned int D.14714;
  void * D.14715;
  unsigned int D.14717;
  long unsigned int D.14718;
  _Bool D.14721;
  long int D.14722;
  long int D.14723;
  void * D.14726;
  void * ptr;
  struct GSList * freelist;

  valloc_freelists.10 = valloc_freelists;
  if (valloc_freelists.10 == 0B) goto <D.14700>; else goto <D.14701>;
  <D.14700>:
  InitializeCriticalSection (&valloc_mutex);
  D.14702 = monoeg_g_hash_table_new (0B, 0B);
  valloc_freelists = D.14702;
  <D.14701>:
  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14703>; else goto <D.14704>;
    <D.14703>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14704>:
    D.14705 = ret != 0;
    D.14706 = (long int) D.14705;
    D.14707 = __builtin_expect (D.14706, 0);
    if (D.14707 != 0) goto <D.14708>; else goto <D.14709>;
    <D.14708>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.14709>:
  }
  valloc_freelists.10 = valloc_freelists;
  D.14710 = (long unsigned int) size;
  D.14711 = (const void *) D.14710;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.10, D.14711);
  if (freelist != 0B) goto <D.14712>; else goto <D.14713>;
  <D.14712>:
  ptr = freelist->data;
  D.14714 = (long unsigned int) size;
  memset (ptr, 0, D.14714);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  valloc_freelists.10 = valloc_freelists;
  D.14710 = (long unsigned int) size;
  D.14715 = (void *) D.14710;
  monoeg_g_hash_table_insert_replace (valloc_freelists.10, D.14715, freelist, 0);
  goto <D.14716>;
  <D.14713>:
  D.14717 = size + 7;
  D.14718 = (long unsigned int) D.14717;
  ptr = mono_valloc (0B, D.14718, 7);
  <D.14716>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14719>; else goto <D.14720>;
    <D.14719>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14720>:
    D.14721 = ret != 0;
    D.14722 = (long int) D.14721;
    D.14723 = __builtin_expect (D.14722, 0);
    if (D.14723 != 0) goto <D.14724>; else goto <D.14725>;
    <D.14724>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.14725>:
  }
  D.14726 = ptr;
  return D.14726;
}


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

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


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.14730;
  long int D.14731;
  long int D.14732;
  struct CodeChunk * D.14735;
  char * D.14740;
  int D.14741;
  sizetype D.14742;
  sizetype D.14743;
  sizetype D.14744;
  char * D.14745;
  int D.14748;
  int D.14749;

  D.14730 = newsize > size;
  D.14731 = (long int) D.14730;
  D.14732 = __builtin_expect (D.14731, 0);
  if (D.14732 != 0) goto <D.14733>; else goto <D.14734>;
  <D.14733>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 702, "newsize <= size");
  <D.14734>:
  D.14735 = cman->current;
  if (D.14735 != 0B) goto <D.14736>; else goto <D.14737>;
  <D.14736>:
  if (size != newsize) goto <D.14738>; else goto <D.14739>;
  <D.14738>:
  D.14735 = cman->current;
  D.14740 = D.14735->data;
  D.14735 = cman->current;
  D.14741 = D.14735->pos;
  D.14742 = (sizetype) D.14741;
  D.14743 = (sizetype) size;
  D.14744 = D.14742 - D.14743;
  D.14745 = D.14740 + D.14744;
  if (D.14745 == data) goto <D.14746>; else goto <D.14747>;
  <D.14746>:
  D.14735 = cman->current;
  D.14735 = cman->current;
  D.14741 = D.14735->pos;
  D.14748 = size - newsize;
  D.14749 = D.14741 - D.14748;
  D.14735->pos = D.14749;
  <D.14747>:
  <D.14739>:
  <D.14737>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.14750;
  unsigned int D.14751;
  int D.14752;
  unsigned int D.14753;
  int used.11;
  int D.14757;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.14523>;
  <D.14522>:
  D.14750 = chunk->size;
  D.14751 = (unsigned int) D.14750;
  size = D.14751 + size;
  D.14752 = chunk->pos;
  D.14753 = (unsigned int) D.14752;
  used = D.14753 + used;
  chunk = chunk->next;
  <D.14523>:
  if (chunk != 0B) goto <D.14522>; else goto <D.14524>;
  <D.14524>:
  chunk = cman->full;
  goto <D.14526>;
  <D.14525>:
  D.14750 = chunk->size;
  D.14751 = (unsigned int) D.14750;
  size = D.14751 + size;
  D.14752 = chunk->pos;
  D.14753 = (unsigned int) D.14752;
  used = D.14753 + used;
  chunk = chunk->next;
  <D.14526>:
  if (chunk != 0B) goto <D.14525>; else goto <D.14527>;
  <D.14527>:
  if (used_size != 0B) goto <D.14754>; else goto <D.14755>;
  <D.14754>:
  used.11 = (int) used;
  *used_size = used.11;
  <D.14755>:
  D.14757 = (int) size;
  return D.14757;
}