mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


codechunk_cleanup ()
{
  struct GHashTable * valloc_freelists.0;
  void * key.1;
  long int key.2;
  unsigned int D.14358;
  long unsigned int D.14359;
  void * D.14360;
  int D.14361;
  struct GHashTableIter iter;
  void * key;
  void * value;

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.14354>; else goto <D.14355>;
      <D.14354>:
      return;
      <D.14355>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.14250>;
      <D.14249>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.14247>;
        <D.14246>:
        key.1 = key;
        key.2 = (long int) key.1;
        D.14358 = (unsigned int) key.2;
        D.14359 = (long unsigned int) D.14358;
        D.14360 = l->data;
        mono_vfree (D.14360, D.14359);
        l = l->next;
        <D.14247>:
        if (l != 0B) goto <D.14246>; else goto <D.14248>;
        <D.14248>:
        monoeg_g_slist_free (freelist);
      }
      <D.14250>:
      D.14361 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.14361 != 0) goto <D.14249>; else goto <D.14251>;
      <D.14251>:
      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.14367;
  struct MonoCodeManager * cman;

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


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

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


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.14371;
  struct CodeChunk * D.14372;

  D.14371 = cman->full;
  free_chunklist (D.14371);
  D.14372 = cman->current;
  free_chunklist (D.14372);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.14373;
  unsigned char D.14374;
  int D.14377;
  unsigned int D.14378;
  long unsigned int code_memory_used.3;
  long unsigned int D.14383;
  long unsigned int code_memory_used.4;
  struct CodeChunk * dead;

  goto <D.14271>;
  <D.14270>:
  dead = chunk;
  D.14373 = dead->data;
  mono_profiler_code_chunk_destroy (D.14373);
  chunk = chunk->next;
  D.14374 = dead->flags;
  if (D.14374 == 0) goto <D.14375>; else goto <D.14376>;
  <D.14375>:
  D.14377 = dead->size;
  D.14378 = (unsigned int) D.14377;
  D.14373 = dead->data;
  codechunk_vfree (D.14373, D.14378);
  goto <D.14379>;
  <D.14376>:
  D.14374 = dead->flags;
  if (D.14374 == 1) goto <D.14380>; else goto <D.14381>;
  <D.14380>:
  D.14373 = dead->data;
  dlfree (D.14373);
  <D.14381>:
  <D.14379>:
  code_memory_used.3 = code_memory_used;
  D.14377 = dead->size;
  D.14383 = (long unsigned int) D.14377;
  code_memory_used.4 = code_memory_used.3 - D.14383;
  code_memory_used = code_memory_used.4;
  free (dead);
  <D.14271>:
  if (chunk != 0B) goto <D.14270>; else goto <D.14272>;
  <D.14272>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.14387;
  long int D.14388;
  long int D.14389;
  long unsigned int D.14392;
  const void * D.14393;
  struct GHashTable * valloc_freelists.5;
  unsigned int D.14399;
  void * D.14400;
  long unsigned int D.14401;
  _Bool D.14404;
  long int D.14405;
  long int D.14406;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14385>; else goto <D.14386>;
    <D.14385>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14386>:
    D.14387 = ret != 0;
    D.14388 = (long int) D.14387;
    D.14389 = __builtin_expect (D.14388, 0);
    if (D.14389 != 0) goto <D.14390>; else goto <D.14391>;
    <D.14390>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.14391>:
  }
  D.14392 = (long unsigned int) size;
  D.14393 = (const void *) D.14392;
  valloc_freelists.5 = valloc_freelists;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.5, D.14393);
  if (freelist == 0B) goto <D.14395>; else goto <D.14398>;
  <D.14398>:
  D.14399 = monoeg_g_slist_length (freelist);
  if (D.14399 <= 15) goto <D.14395>; else goto <D.14396>;
  <D.14395>:
  freelist = monoeg_g_slist_prepend (freelist, ptr);
  D.14392 = (long unsigned int) size;
  D.14400 = (void *) D.14392;
  valloc_freelists.5 = valloc_freelists;
  monoeg_g_hash_table_insert_replace (valloc_freelists.5, D.14400, freelist, 0);
  goto <D.14397>;
  <D.14396>:
  D.14401 = (long unsigned int) size;
  mono_vfree (ptr, D.14401);
  <D.14397>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14402>; else goto <D.14403>;
    <D.14402>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14403>:
    D.14404 = ret != 0;
    D.14405 = (long int) D.14404;
    D.14406 = __builtin_expect (D.14405, 0);
    if (D.14406 != 0) goto <D.14407>; else goto <D.14408>;
    <D.14407>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.14408>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  int D.14409;
  long unsigned int D.14410;
  char * D.14411;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 204;
  chunk = cman->current;
  goto <D.14282>;
  <D.14281>:
  D.14409 = chunk->size;
  D.14410 = (long unsigned int) D.14409;
  D.14411 = chunk->data;
  memset (D.14411, fill_value, D.14410);
  chunk = chunk->next;
  <D.14282>:
  if (chunk != 0B) goto <D.14281>; else goto <D.14283>;
  <D.14283>:
  chunk = cman->full;
  goto <D.14285>;
  <D.14284>:
  D.14409 = chunk->size;
  D.14410 = (long unsigned int) D.14409;
  D.14411 = chunk->data;
  memset (D.14411, fill_value, D.14410);
  chunk = chunk->next;
  <D.14285>:
  if (chunk != 0B) goto <D.14284>; else goto <D.14286>;
  <D.14286>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14414;
  int D.14419;
  void * D.14421;
  long unsigned int D.14422;

  D.14414 = __builtin_constant_p (__len);
  if (D.14414 != 0) goto <D.14415>; else goto <D.14416>;
  <D.14415>:
  if (__len == 0) goto <D.14417>; else goto <D.14418>;
  <D.14417>:
  D.14419 = __builtin_constant_p (__ch);
  if (D.14419 == 0) goto <D.14412>; else goto <D.14420>;
  <D.14420>:
  if (__ch != 0) goto <D.14412>; else goto <D.14413>;
  <D.14412>:
  __warn_memset_zero_len ();
  D.14421 = __dest;
  return D.14421;
  <D.14413>:
  <D.14418>:
  <D.14416>:
  D.14422 = __builtin_object_size (__dest, 0);
  D.14421 = __builtin___memset_chk (__dest, __ch, __len, D.14422);
  return D.14421;
}


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.14424;
  int D.14425;
  int D.14426;
  char * D.14427;
  int D.14428;
  int D.14431;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.14297>;
  <D.14296>:
  D.14424 = chunk->bsize;
  D.14425 = (int) D.14424;
  D.14426 = chunk->size;
  D.14427 = chunk->data;
  D.14428 = func (D.14427, D.14426, D.14425, user_data);
  if (D.14428 != 0) goto <D.14429>; else goto <D.14430>;
  <D.14429>:
  return;
  <D.14430>:
  chunk = chunk->next;
  <D.14297>:
  if (chunk != 0B) goto <D.14296>; else goto <D.14298>;
  <D.14298>:
  chunk = cman->full;
  goto <D.14300>;
  <D.14299>:
  D.14424 = chunk->bsize;
  D.14425 = (int) D.14424;
  D.14426 = chunk->size;
  D.14427 = chunk->data;
  D.14431 = func (D.14427, D.14426, D.14425, user_data);
  if (D.14431 != 0) goto <D.14432>; else goto <D.14433>;
  <D.14432>:
  return;
  <D.14433>:
  chunk = chunk->next;
  <D.14300>:
  if (chunk != 0B) goto <D.14299>; else goto <D.14301>;
  <D.14301>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.14435;
  int D.14436;
  _Bool D.14437;
  long int D.14438;
  long int D.14439;
  _Bool D.14442;
  long int D.14443;
  long int D.14444;
  int D.14447;
  long unsigned int D.14450;
  long unsigned int D.14451;
  long unsigned int D.14452;
  long unsigned int D.14453;
  long unsigned int D.14454;
  struct CodeChunk * D.14455;
  struct CodeChunk * D.14458;
  void * D.14461;
  int D.14462;
  int D.14463;
  int D.14464;
  int D.14465;
  int D.14466;
  int D.14467;
  char * D.14470;
  long unsigned int D.14471;
  long unsigned int D.14472;
  long unsigned int D.14473;
  long unsigned int D.14474;
  long unsigned int D.14475;
  long unsigned int D.14476;
  long unsigned int D.14477;
  long int ptr.6;
  long int D.14479;
  long int D.14480;
  unsigned int D.14481;
  unsigned int size.7;
  unsigned int D.14483;
  int D.14484;
  int D.14485;
  struct CodeChunk * D.14490;
  struct CodeChunk * D.14492;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.14435 = alignment + -1;
  align_mask = (guint32) D.14435;
  D.14436 = cman->read_only;
  D.14437 = D.14436 != 0;
  D.14438 = (long int) D.14437;
  D.14439 = __builtin_expect (D.14438, 0);
  if (D.14439 != 0) goto <D.14440>; else goto <D.14441>;
  <D.14440>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.14441>:
  D.14442 = alignment > 16;
  D.14443 = (long int) D.14442;
  D.14444 = __builtin_expect (D.14443, 0);
  if (D.14444 != 0) goto <D.14445>; else goto <D.14446>;
  <D.14445>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.14446>:
  D.14447 = cman->dynamic;
  if (D.14447 != 0) goto <D.14448>; else goto <D.14449>;
  <D.14448>:
  D.14450 = mono_stats.dynamic_code_alloc_count;
  D.14451 = D.14450 + 1;
  mono_stats.dynamic_code_alloc_count = D.14451;
  D.14452 = mono_stats.dynamic_code_bytes_count;
  D.14453 = (long unsigned int) size;
  D.14454 = D.14452 + D.14453;
  mono_stats.dynamic_code_bytes_count = D.14454;
  <D.14449>:
  D.14455 = cman->current;
  if (D.14455 == 0B) goto <D.14456>; else goto <D.14457>;
  <D.14456>:
  D.14447 = cman->dynamic;
  D.14458 = new_codechunk (D.14447, size);
  cman->current = D.14458;
  D.14455 = cman->current;
  if (D.14455 == 0B) goto <D.14459>; else goto <D.14460>;
  <D.14459>:
  D.14461 = 0B;
  return D.14461;
  <D.14460>:
  <D.14457>:
  chunk = cman->current;
  goto <D.14323>;
  <D.14322>:
  D.14462 = chunk->pos;
  D.14435 = alignment + -1;
  D.14463 = D.14462 + D.14435;
  D.14464 = -alignment;
  D.14465 = D.14463 & D.14464;
  D.14466 = D.14465 + size;
  D.14467 = chunk->size;
  if (D.14466 <= D.14467) goto <D.14468>; else goto <D.14469>;
  <D.14468>:
  D.14462 = chunk->pos;
  D.14435 = alignment + -1;
  D.14463 = D.14462 + D.14435;
  D.14464 = -alignment;
  D.14465 = D.14463 & D.14464;
  chunk->pos = D.14465;
  D.14470 = chunk->data;
  D.14471 = (long unsigned int) D.14470;
  D.14472 = (long unsigned int) align_mask;
  D.14473 = D.14471 + D.14472;
  D.14472 = (long unsigned int) align_mask;
  D.14474 = ~D.14472;
  D.14475 = D.14473 & D.14474;
  D.14462 = chunk->pos;
  D.14476 = (long unsigned int) D.14462;
  D.14477 = D.14475 + D.14476;
  ptr = (void *) D.14477;
  ptr.6 = (long int) ptr;
  D.14470 = chunk->data;
  D.14479 = (long int) D.14470;
  D.14480 = ptr.6 - D.14479;
  D.14481 = (unsigned int) D.14480;
  size.7 = (unsigned int) size;
  D.14483 = D.14481 + size.7;
  D.14484 = (int) D.14483;
  chunk->pos = D.14484;
  D.14461 = ptr;
  return D.14461;
  <D.14469>:
  chunk = chunk->next;
  <D.14323>:
  if (chunk != 0B) goto <D.14322>; else goto <D.14324>;
  <D.14324>:
  prev = 0B;
  chunk = cman->current;
  goto <D.14328>;
  <D.14327>:
  D.14462 = chunk->pos;
  D.14485 = D.14462 + 63;
  D.14467 = chunk->size;
  if (D.14485 < D.14467) goto <D.14486>; else goto <D.14487>;
  <D.14486>:
  // predicted unlikely by continue predictor.
  goto <D.14325>;
  <D.14487>:
  if (prev != 0B) goto <D.14488>; else goto <D.14489>;
  <D.14488>:
  D.14490 = chunk->next;
  prev->next = D.14490;
  goto <D.14491>;
  <D.14489>:
  D.14490 = chunk->next;
  cman->current = D.14490;
  <D.14491>:
  D.14492 = cman->full;
  chunk->next = D.14492;
  cman->full = chunk;
  goto <D.14326>;
  <D.14325>:
  prev = chunk;
  chunk = chunk->next;
  <D.14328>:
  if (chunk != 0B) goto <D.14327>; else goto <D.14326>;
  <D.14326>:
  D.14447 = cman->dynamic;
  chunk = new_codechunk (D.14447, size);
  if (chunk == 0B) goto <D.14493>; else goto <D.14494>;
  <D.14493>:
  D.14461 = 0B;
  return D.14461;
  <D.14494>:
  D.14455 = cman->current;
  chunk->next = D.14455;
  cman->current = chunk;
  D.14462 = chunk->pos;
  D.14435 = alignment + -1;
  D.14463 = D.14462 + D.14435;
  D.14464 = -alignment;
  D.14465 = D.14463 & D.14464;
  chunk->pos = D.14465;
  D.14470 = chunk->data;
  D.14471 = (long unsigned int) D.14470;
  D.14472 = (long unsigned int) align_mask;
  D.14473 = D.14471 + D.14472;
  D.14472 = (long unsigned int) align_mask;
  D.14474 = ~D.14472;
  D.14475 = D.14473 & D.14474;
  D.14462 = chunk->pos;
  D.14476 = (long unsigned int) D.14462;
  D.14477 = D.14475 + D.14476;
  ptr = (void *) D.14477;
  ptr.6 = (long int) ptr;
  D.14470 = chunk->data;
  D.14479 = (long int) D.14470;
  D.14480 = ptr.6 - D.14479;
  D.14481 = (unsigned int) D.14480;
  size.7 = (unsigned int) size;
  D.14483 = D.14481 + size.7;
  D.14484 = (int) D.14483;
  chunk->pos = D.14484;
  D.14461 = ptr;
  return D.14461;
}


new_codechunk (int dynamic, int size)
{
  int D.14502;
  int D.14503;
  int D.14506;
  long unsigned int D.14507;
  struct CodeChunk * D.14510;
  unsigned int chunk_size.8;
  long unsigned int D.14522;
  unsigned char D.14523;
  unsigned int bsize.9;
  <unnamed-unsigned:24> D.14525;
  int D.14526;
  char * D.14527;
  long unsigned int D.14528;
  long unsigned int code_memory_used.10;
  long unsigned int code_memory_used.11;
  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.14496>; else goto <D.14497>;
  <D.14496>:
  chunk_size = size;
  flags = 1;
  goto <D.14498>;
  <D.14497>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.14499>; else goto <D.14500>;
  <D.14499>:
  chunk_size = minsize;
  goto <D.14501>;
  <D.14500>:
  chunk_size = size;
  D.14502 = pagesize + -1;
  chunk_size = D.14502 + chunk_size;
  D.14503 = -pagesize;
  chunk_size = D.14503 & chunk_size;
  <D.14501>:
  <D.14498>:
  if (flags == 1) goto <D.14504>; else goto <D.14505>;
  <D.14504>:
  D.14506 = chunk_size + 15;
  D.14507 = (long unsigned int) D.14506;
  ptr = dlmemalign (16, D.14507);
  if (ptr == 0B) goto <D.14508>; else goto <D.14509>;
  <D.14508>:
  D.14510 = 0B;
  return D.14510;
  <D.14509>:
  goto <D.14511>;
  <D.14505>:
  chunk_size.8 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.8);
  if (ptr == 0B) goto <D.14513>; else goto <D.14514>;
  <D.14513>:
  D.14510 = 0B;
  return D.14510;
  <D.14514>:
  <D.14511>:
  if (flags == 1) goto <D.14515>; else goto <D.14516>;
  <D.14515>:
  <D.14516>:
  chunk = malloc (32);
  if (chunk == 0B) goto <D.14517>; else goto <D.14518>;
  <D.14517>:
  if (flags == 1) goto <D.14519>; else goto <D.14520>;
  <D.14519>:
  dlfree (ptr);
  goto <D.14521>;
  <D.14520>:
  D.14522 = (long unsigned int) chunk_size;
  mono_vfree (ptr, D.14522);
  <D.14521>:
  D.14510 = 0B;
  return D.14510;
  <D.14518>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.14523 = (unsigned char) flags;
  chunk->flags = D.14523;
  chunk->pos = bsize;
  bsize.9 = (unsigned int) bsize;
  D.14525 = (<unnamed-unsigned:24>) bsize.9;
  chunk->bsize = D.14525;
  D.14526 = chunk->size;
  D.14527 = chunk->data;
  mono_profiler_code_chunk_new (D.14527, D.14526);
  D.14528 = (long unsigned int) chunk_size;
  code_memory_used.10 = code_memory_used;
  code_memory_used.11 = D.14528 + code_memory_used.10;
  code_memory_used = code_memory_used.11;
  code_memory_used.10 = code_memory_used;
  mono_runtime_resource_check_limit (0, code_memory_used.10);
  D.14510 = chunk;
  return D.14510;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.12;
  struct GHashTable * valloc_freelists.13;
  _Bool D.14538;
  long int D.14539;
  long int D.14540;
  long unsigned int D.14543;
  const void * D.14544;
  long unsigned int D.14547;
  void * D.14548;
  unsigned int D.14550;
  long unsigned int D.14551;
  _Bool D.14554;
  long int D.14555;
  long int D.14556;
  void * D.14559;
  void * ptr;
  struct GSList * freelist;

  valloc_freelists.12 = valloc_freelists;
  if (valloc_freelists.12 == 0B) goto <D.14533>; else goto <D.14534>;
  <D.14533>:
  InitializeCriticalSection (&valloc_mutex);
  valloc_freelists.13 = monoeg_g_hash_table_new (0B, 0B);
  valloc_freelists = valloc_freelists.13;
  <D.14534>:
  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14536>; else goto <D.14537>;
    <D.14536>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14537>:
    D.14538 = ret != 0;
    D.14539 = (long int) D.14538;
    D.14540 = __builtin_expect (D.14539, 0);
    if (D.14540 != 0) goto <D.14541>; else goto <D.14542>;
    <D.14541>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.14542>:
  }
  D.14543 = (long unsigned int) size;
  D.14544 = (const void *) D.14543;
  valloc_freelists.12 = valloc_freelists;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.12, D.14544);
  if (freelist != 0B) goto <D.14545>; else goto <D.14546>;
  <D.14545>:
  ptr = freelist->data;
  D.14547 = (long unsigned int) size;
  memset (ptr, 0, D.14547);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  D.14543 = (long unsigned int) size;
  D.14548 = (void *) D.14543;
  valloc_freelists.12 = valloc_freelists;
  monoeg_g_hash_table_insert_replace (valloc_freelists.12, D.14548, freelist, 0);
  goto <D.14549>;
  <D.14546>:
  D.14550 = size + 15;
  D.14551 = (long unsigned int) D.14550;
  ptr = mono_valloc (0B, D.14551, 263);
  <D.14549>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14552>; else goto <D.14553>;
    <D.14552>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14553>:
    D.14554 = ret != 0;
    D.14555 = (long int) D.14554;
    D.14556 = __builtin_expect (D.14555, 0);
    if (D.14556 != 0) goto <D.14557>; else goto <D.14558>;
    <D.14557>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.14558>:
  }
  D.14559 = ptr;
  return D.14559;
}


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

  D.14561 = mono_code_manager_reserve_align (cman, size, 16);
  return D.14561;
}


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.14563;
  long int D.14564;
  long int D.14565;
  struct CodeChunk * D.14568;
  char * D.14573;
  int D.14574;
  sizetype D.14575;
  sizetype D.14576;
  sizetype D.14577;
  char * D.14578;
  int D.14581;
  int D.14582;

  D.14563 = newsize > size;
  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", 702, "newsize <= size");
  <D.14567>:
  D.14568 = cman->current;
  if (D.14568 != 0B) goto <D.14569>; else goto <D.14570>;
  <D.14569>:
  if (size != newsize) goto <D.14571>; else goto <D.14572>;
  <D.14571>:
  D.14568 = cman->current;
  D.14573 = D.14568->data;
  D.14568 = cman->current;
  D.14574 = D.14568->pos;
  D.14575 = (sizetype) D.14574;
  D.14576 = (sizetype) size;
  D.14577 = D.14575 - D.14576;
  D.14578 = D.14573 + D.14577;
  if (D.14578 == data) goto <D.14579>; else goto <D.14580>;
  <D.14579>:
  D.14568 = cman->current;
  D.14568 = cman->current;
  D.14574 = D.14568->pos;
  D.14581 = newsize - size;
  D.14582 = D.14574 + D.14581;
  D.14568->pos = D.14582;
  <D.14580>:
  <D.14572>:
  <D.14570>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.14583;
  unsigned int D.14584;
  int D.14585;
  unsigned int D.14586;
  int used.14;
  int D.14590;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.14347>;
  <D.14346>:
  D.14583 = chunk->size;
  D.14584 = (unsigned int) D.14583;
  size = D.14584 + size;
  D.14585 = chunk->pos;
  D.14586 = (unsigned int) D.14585;
  used = D.14586 + used;
  chunk = chunk->next;
  <D.14347>:
  if (chunk != 0B) goto <D.14346>; else goto <D.14348>;
  <D.14348>:
  chunk = cman->full;
  goto <D.14350>;
  <D.14349>:
  D.14583 = chunk->size;
  D.14584 = (unsigned int) D.14583;
  size = D.14584 + size;
  D.14585 = chunk->pos;
  D.14586 = (unsigned int) D.14585;
  used = D.14586 + used;
  chunk = chunk->next;
  <D.14350>:
  if (chunk != 0B) goto <D.14349>; else goto <D.14351>;
  <D.14351>:
  if (used_size != 0B) goto <D.14587>; else goto <D.14588>;
  <D.14587>:
  used.14 = (int) used;
  *used_size = used.14;
  <D.14588>:
  D.14590 = (int) size;
  return D.14590;
}