mono_mempool_new ()
{
  struct MonoMemPool * D.7330;

  D.7330 = mono_mempool_new_size (8192);
  return D.7330;
}


mono_mempool_new_size (int initial_size)
{
  unsigned int initial_size.0;
  guint8 * D.7335;
  guint8 * D.7336;
  sizetype initial_size.1;
  sizetype D.7338;
  guint8 * D.7339;
  unsigned int initial_size.2;
  unsigned int D.7341;
  long int total_bytes_allocated.3;
  long int total_bytes_allocated.4;
  struct MonoMemPool * D.7344;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.7332>; else goto <D.7333>;
  <D.7332>:
  initial_size = 512;
  <D.7333>:
  initial_size.0 = (unsigned int) initial_size;
  pool = monoeg_malloc (initial_size.0);
  pool->next = 0B;
  D.7335 = pool + 32;
  pool->pos = D.7335;
  D.7336 = pool->pos;
  initial_size.1 = (sizetype) initial_size;
  D.7338 = initial_size.1 + 4294967264;
  D.7339 = D.7336 + D.7338;
  pool->end = D.7339;
  initial_size.2 = (unsigned int) initial_size;
  pool->size = initial_size.2;
  D.7341 = pool->size;
  pool->d.allocated = D.7341;
  total_bytes_allocated.3 = total_bytes_allocated;
  total_bytes_allocated.4 = total_bytes_allocated.3 + initial_size;
  total_bytes_allocated = total_bytes_allocated.4;
  D.7344 = pool;
  return D.7344;
}


mono_mempool_destroy (struct MonoMemPool * pool)
{
  long int total_bytes_allocated.5;
  long unsigned int total_bytes_allocated.6;
  unsigned int D.7348;
  long unsigned int D.7349;
  long int total_bytes_allocated.7;
  struct MonoMemPool * p;
  struct MonoMemPool * n;

  total_bytes_allocated.5 = total_bytes_allocated;
  total_bytes_allocated.6 = (long unsigned int) total_bytes_allocated.5;
  D.7348 = pool->d.allocated;
  D.7349 = total_bytes_allocated.6 - D.7348;
  total_bytes_allocated.7 = (long int) D.7349;
  total_bytes_allocated = total_bytes_allocated.7;
  p = pool;
  goto <D.7264>;
  <D.7263>:
  n = p->next;
  monoeg_g_free (p);
  p = n;
  <D.7264>:
  if (p != 0B) goto <D.7263>; else goto <D.7265>;
  <D.7265>:
}


mono_mempool_invalidate (struct MonoMemPool * pool)
{
  unsigned int D.7351;
  struct MonoMemPool * p;
  struct MonoMemPool * n;

  p = pool;
  goto <D.7272>;
  <D.7271>:
  n = p->next;
  D.7351 = p->size;
  memset (p, 42, D.7351);
  p = n;
  <D.7272>:
  if (p != 0B) goto <D.7271>; else goto <D.7273>;
  <D.7273>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7354;
  int D.7359;
  void * D.7361;
  unsigned int D.7362;

  D.7354 = __builtin_constant_p (__len);
  if (D.7354 != 0) goto <D.7355>; else goto <D.7356>;
  <D.7355>:
  if (__len == 0) goto <D.7357>; else goto <D.7358>;
  <D.7357>:
  D.7359 = __builtin_constant_p (__ch);
  if (D.7359 == 0) goto <D.7352>; else goto <D.7360>;
  <D.7360>:
  if (__ch != 0) goto <D.7352>; else goto <D.7353>;
  <D.7352>:
  __warn_memset_zero_len ();
  D.7361 = __dest;
  return D.7361;
  <D.7353>:
  <D.7358>:
  <D.7356>:
  D.7362 = __builtin_object_size (__dest, 0);
  D.7361 = __builtin___memset_chk (__dest, __ch, __len, D.7362);
  return D.7361;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.7364;
  guint8 * D.7365;
  unsigned int D.7366;
  sizetype D.7367;
  guint8 * D.7368;

  D.7364 = pool + 32;
  pool->pos = D.7364;
  D.7365 = pool->pos;
  D.7366 = pool->size;
  D.7367 = D.7366 + 4294967264;
  D.7368 = D.7365 + D.7367;
  pool->end = D.7368;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.7369;
  int D.7370;
  guint8 * D.7371;
  int D.7372;
  int D.7373;
  unsigned int D.7374;
  unsigned int D.7377;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.7284>;
  <D.7283>:
  D.7369 = p->end;
  D.7370 = (int) D.7369;
  D.7371 = p->pos;
  D.7372 = (int) D.7371;
  D.7373 = D.7370 - D.7372;
  D.7374 = (unsigned int) D.7373;
  still_free = D.7374 + still_free;
  p = p->next;
  count = count + 1;
  <D.7284>:
  if (p != 0B) goto <D.7283>; else goto <D.7285>;
  <D.7285>:
  if (pool != 0B) goto <D.7375>; else goto <D.7376>;
  <D.7375>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.7377 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.7377);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.7376>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.7378;
  guint8 * D.7379;
  guint8 * D.7380;
  guint8 * D.7381;
  _Bool D.7382;
  long int D.7383;
  long int D.7384;
  sizetype D.7387;
  guint8 * D.7388;
  unsigned int D.7391;
  struct MonoMemPool * D.7392;
  guint8 * D.7393;
  guint8 * D.7394;
  unsigned int D.7395;
  sizetype D.7396;
  guint8 * D.7397;
  unsigned int D.7398;
  unsigned int D.7399;
  unsigned int D.7400;
  long int total_bytes_allocated.8;
  long unsigned int total_bytes_allocated.9;
  long unsigned int D.7403;
  long unsigned int D.7404;
  long int total_bytes_allocated.10;
  void * D.7406;
  int size.11;
  unsigned int new_size.12;
  guint8 * D.7409;
  unsigned int new_size.13;
  guint8 * D.7411;
  sizetype new_size.14;
  sizetype D.7413;
  guint8 * D.7414;
  unsigned int D.7415;
  long int total_bytes_allocated.15;
  guint8 * D.7417;
  void * rval;

  D.7378 = size + 7;
  size = D.7378 & 4294967288;
  rval = pool->pos;
  D.7379 = rval + size;
  pool->pos = D.7379;
  D.7380 = pool->pos;
  D.7381 = pool->end;
  D.7382 = D.7380 >= D.7381;
  D.7383 = (long int) D.7382;
  D.7384 = __builtin_expect (D.7383, 0);
  if (D.7384 != 0) goto <D.7385>; else goto <D.7386>;
  <D.7385>:
  D.7380 = pool->pos;
  D.7387 = -size;
  D.7388 = D.7380 + D.7387;
  pool->pos = D.7388;
  if (size > 4095) goto <D.7389>; else goto <D.7390>;
  <D.7389>:
  {
    struct MonoMemPool * np;

    D.7391 = size + 32;
    np = monoeg_malloc (D.7391);
    D.7392 = pool->next;
    np->next = D.7392;
    pool->next = np;
    D.7393 = np + 32;
    np->pos = D.7393;
    D.7391 = size + 32;
    np->size = D.7391;
    D.7394 = np->pos;
    D.7395 = np->size;
    D.7396 = D.7395 + 4294967264;
    D.7397 = D.7394 + D.7396;
    np->end = D.7397;
    D.7398 = pool->d.allocated;
    D.7399 = D.7398 + size;
    D.7400 = D.7399 + 32;
    pool->d.allocated = D.7400;
    total_bytes_allocated.8 = total_bytes_allocated;
    total_bytes_allocated.9 = (long unsigned int) total_bytes_allocated.8;
    D.7403 = size + total_bytes_allocated.9;
    D.7404 = D.7403 + 32;
    total_bytes_allocated.10 = (long int) D.7404;
    total_bytes_allocated = total_bytes_allocated.10;
    D.7406 = np + 32;
    return D.7406;
  }
  <D.7390>:
  {
    int new_size;
    struct MonoMemPool * np;

    size.11 = (int) size;
    new_size = get_next_size (pool, size.11);
    new_size.12 = (unsigned int) new_size;
    np = monoeg_malloc (new_size.12);
    D.7392 = pool->next;
    np->next = D.7392;
    pool->next = np;
    D.7409 = np + 32;
    pool->pos = D.7409;
    D.7409 = np + 32;
    np->pos = D.7409;
    new_size.13 = (unsigned int) new_size;
    np->size = new_size.13;
    D.7411 = np->pos;
    np->end = D.7411;
    D.7380 = pool->pos;
    new_size.14 = (sizetype) new_size;
    D.7413 = new_size.14 + 4294967264;
    D.7414 = D.7380 + D.7413;
    pool->end = D.7414;
    D.7398 = pool->d.allocated;
    new_size.13 = (unsigned int) new_size;
    D.7415 = D.7398 + new_size.13;
    pool->d.allocated = D.7415;
    total_bytes_allocated.8 = total_bytes_allocated;
    total_bytes_allocated.15 = total_bytes_allocated.8 + new_size;
    total_bytes_allocated = total_bytes_allocated.15;
    rval = pool->pos;
    D.7380 = pool->pos;
    D.7417 = D.7380 + size;
    pool->pos = D.7417;
  }
  <D.7386>:
  D.7406 = rval;
  return D.7406;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.16;
  struct MonoMemPool * D.7420;
  unsigned int D.7423;
  unsigned int D.7425;
  unsigned int size.17;
  unsigned int D.7427;
  int D.7428;
  _Bool D.7429;
  _Bool D.7430;
  _Bool D.7431;
  int D.7434;
  int target;

  D.7420 = pool->next;
  if (D.7420 != 0B) goto <D.7421>; else goto <D.7422>;
  <D.7421>:
  D.7420 = pool->next;
  D.7423 = D.7420->size;
  iftmp.16 = (int) D.7423;
  goto <D.7424>;
  <D.7422>:
  D.7425 = pool->size;
  iftmp.16 = (int) D.7425;
  <D.7424>:
  target = iftmp.16;
  size.17 = (unsigned int) size;
  D.7427 = size.17 + 32;
  size = (int) D.7427;
  D.7428 = target / 2;
  target = D.7428 + target;
  goto <D.7292>;
  <D.7291>:
  D.7428 = target / 2;
  target = D.7428 + target;
  <D.7292>:
  if (target < size) goto <D.7291>; else goto <D.7293>;
  <D.7293>:
  D.7429 = target > 8192;
  D.7430 = size <= 8192;
  D.7431 = D.7429 & D.7430;
  if (D.7431 != 0) goto <D.7432>; else goto <D.7433>;
  <D.7432>:
  target = 8192;
  <D.7433>:
  D.7434 = target;
  return D.7434;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.7436;
  guint8 * D.7437;
  guint8 * D.7438;
  guint8 * D.7439;
  _Bool D.7440;
  long int D.7441;
  long int D.7442;
  void * D.7445;
  void * rval;

  D.7436 = size + 7;
  size = D.7436 & 4294967288;
  rval = pool->pos;
  D.7437 = rval + size;
  pool->pos = D.7437;
  D.7438 = pool->pos;
  D.7439 = pool->end;
  D.7440 = D.7438 >= D.7439;
  D.7441 = (long int) D.7440;
  D.7442 = __builtin_expect (D.7441, 0);
  if (D.7442 != 0) goto <D.7443>; else goto <D.7444>;
  <D.7443>:
  rval = mono_mempool_alloc (pool, size);
  <D.7444>:
  memset (rval, 0, size);
  D.7445 = rval;
  return D.7445;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.7449;
  void * D.7450;
  mono_bool D.7453;
  struct MonoMemPool * p;

  p = pool;
  goto <D.7313>;
  <D.7312>:
  if (addr > p) goto <D.7447>; else goto <D.7448>;
  <D.7447>:
  D.7449 = p->size;
  D.7450 = p + D.7449;
  if (D.7450 >= addr) goto <D.7451>; else goto <D.7452>;
  <D.7451>:
  D.7453 = 1;
  return D.7453;
  <D.7452>:
  <D.7448>:
  p = p->next;
  <D.7313>:
  if (p != 0B) goto <D.7312>; else goto <D.7314>;
  <D.7314>:
  D.7453 = 0;
  return D.7453;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.7457;
  unsigned int D.7458;
  int D.7459;
  unsigned int D.7460;
  unsigned int D.7461;
  int l;
  char * res;

  if (s == 0B) goto <D.7455>; else goto <D.7456>;
  <D.7455>:
  D.7457 = 0B;
  return D.7457;
  <D.7456>:
  D.7458 = strlen (s);
  l = (int) D.7458;
  D.7459 = l + 1;
  D.7460 = (unsigned int) D.7459;
  res = mono_mempool_alloc (pool, D.7460);
  D.7459 = l + 1;
  D.7461 = (unsigned int) D.7459;
  memcpy (res, s, D.7461);
  D.7457 = res;
  return D.7457;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.7463;
  unsigned int D.7464;

  D.7464 = __builtin_object_size (__dest, 0);
  D.7463 = __builtin___memcpy_chk (__dest, __src, __len, D.7464);
  return D.7463;
}


mono_mempool_get_allocated (struct MonoMemPool * pool)
{
  uint32_t D.7466;

  D.7466 = pool->d.allocated;
  return D.7466;
}


mono_mempool_get_bytes_allocated ()
{
  long int D.7468;

  D.7468 = total_bytes_allocated;
  return D.7468;
}