mono_mempool_new ()
{
  struct MonoMemPool * D.5585;

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


mono_mempool_new_size (int initial_size)
{
  long unsigned int D.5589;
  guint8 * D.5590;
  guint8 * D.5591;
  sizetype D.5592;
  sizetype D.5593;
  guint8 * D.5594;
  unsigned int initial_size.0;
  unsigned int D.5596;
  long int D.5597;
  long int total_bytes_allocated.1;
  long int total_bytes_allocated.2;
  struct MonoMemPool * D.5600;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.5587>; else goto <D.5588>;
  <D.5587>:
  initial_size = 512;
  <D.5588>:
  D.5589 = (long unsigned int) initial_size;
  pool = monoeg_malloc (D.5589);
  pool->next = 0B;
  D.5590 = pool + 48;
  pool->pos = D.5590;
  D.5591 = pool->pos;
  D.5592 = (sizetype) initial_size;
  D.5593 = D.5592 + 18446744073709551568;
  D.5594 = D.5591 + D.5593;
  pool->end = D.5594;
  initial_size.0 = (unsigned int) initial_size;
  pool->size = initial_size.0;
  D.5596 = pool->size;
  pool->d.allocated = D.5596;
  D.5597 = (long int) initial_size;
  total_bytes_allocated.1 = total_bytes_allocated;
  total_bytes_allocated.2 = D.5597 + total_bytes_allocated.1;
  total_bytes_allocated = total_bytes_allocated.2;
  D.5600 = pool;
  return D.5600;
}


mono_mempool_destroy (struct MonoMemPool * pool)
{
  long int total_bytes_allocated.3;
  unsigned int D.5603;
  long int D.5604;
  long int total_bytes_allocated.4;
  struct MonoMemPool * p;
  struct MonoMemPool * n;

  total_bytes_allocated.3 = total_bytes_allocated;
  D.5603 = pool->d.allocated;
  D.5604 = (long int) D.5603;
  total_bytes_allocated.4 = total_bytes_allocated.3 - D.5604;
  total_bytes_allocated = total_bytes_allocated.4;
  p = pool;
  goto <D.5521>;
  <D.5520>:
  n = p->next;
  monoeg_g_free (p);
  p = n;
  <D.5521>:
  if (p != 0B) goto <D.5520>; else goto <D.5522>;
  <D.5522>:
}


mono_mempool_invalidate (struct MonoMemPool * pool)
{
  unsigned int D.5606;
  long unsigned int D.5607;
  struct MonoMemPool * p;
  struct MonoMemPool * n;

  p = pool;
  goto <D.5529>;
  <D.5528>:
  n = p->next;
  D.5606 = p->size;
  D.5607 = (long unsigned int) D.5606;
  memset (p, 42, D.5607);
  p = n;
  <D.5529>:
  if (p != 0B) goto <D.5528>; else goto <D.5530>;
  <D.5530>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5610;
  int D.5615;
  void * D.5617;
  long unsigned int D.5618;

  D.5610 = __builtin_constant_p (__len);
  if (D.5610 != 0) goto <D.5611>; else goto <D.5612>;
  <D.5611>:
  if (__len == 0) goto <D.5613>; else goto <D.5614>;
  <D.5613>:
  D.5615 = __builtin_constant_p (__ch);
  if (D.5615 == 0) goto <D.5608>; else goto <D.5616>;
  <D.5616>:
  if (__ch != 0) goto <D.5608>; else goto <D.5609>;
  <D.5608>:
  __warn_memset_zero_len ();
  D.5617 = __dest;
  return D.5617;
  <D.5609>:
  <D.5614>:
  <D.5612>:
  D.5618 = __builtin_object_size (__dest, 0);
  D.5617 = __builtin___memset_chk (__dest, __ch, __len, D.5618);
  return D.5617;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.5620;
  guint8 * D.5621;
  unsigned int D.5622;
  sizetype D.5623;
  sizetype D.5624;
  guint8 * D.5625;

  D.5620 = pool + 48;
  pool->pos = D.5620;
  D.5621 = pool->pos;
  D.5622 = pool->size;
  D.5623 = (sizetype) D.5622;
  D.5624 = D.5623 + 18446744073709551568;
  D.5625 = D.5621 + D.5624;
  pool->end = D.5625;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.5626;
  long int D.5627;
  guint8 * D.5628;
  long int D.5629;
  long int D.5630;
  unsigned int D.5631;
  unsigned int D.5634;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.5541>;
  <D.5540>:
  D.5626 = p->end;
  D.5627 = (long int) D.5626;
  D.5628 = p->pos;
  D.5629 = (long int) D.5628;
  D.5630 = D.5627 - D.5629;
  D.5631 = (unsigned int) D.5630;
  still_free = D.5631 + still_free;
  p = p->next;
  count = count + 1;
  <D.5541>:
  if (p != 0B) goto <D.5540>; else goto <D.5542>;
  <D.5542>:
  if (pool != 0B) goto <D.5632>; else goto <D.5633>;
  <D.5632>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.5634 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.5634);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.5633>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5635;
  sizetype D.5636;
  guint8 * D.5637;
  guint8 * D.5638;
  guint8 * D.5639;
  _Bool D.5640;
  long int D.5641;
  long int D.5642;
  sizetype D.5645;
  guint8 * D.5646;
  long unsigned int D.5649;
  long unsigned int D.5650;
  struct MonoMemPool * D.5651;
  guint8 * D.5652;
  unsigned int D.5653;
  guint8 * D.5654;
  unsigned int D.5655;
  sizetype D.5656;
  sizetype D.5657;
  guint8 * D.5658;
  unsigned int D.5659;
  unsigned int D.5660;
  unsigned int D.5661;
  long int total_bytes_allocated.5;
  long unsigned int total_bytes_allocated.6;
  long unsigned int D.5664;
  long unsigned int D.5665;
  long int total_bytes_allocated.7;
  void * D.5667;
  int size.8;
  long unsigned int D.5669;
  guint8 * D.5670;
  unsigned int new_size.9;
  guint8 * D.5672;
  sizetype D.5673;
  sizetype D.5674;
  guint8 * D.5675;
  unsigned int D.5676;
  long int D.5677;
  long int total_bytes_allocated.10;
  guint8 * D.5679;
  void * rval;

  D.5635 = size + 7;
  size = D.5635 & 4294967288;
  rval = pool->pos;
  D.5636 = (sizetype) size;
  D.5637 = rval + D.5636;
  pool->pos = D.5637;
  D.5638 = pool->pos;
  D.5639 = pool->end;
  D.5640 = D.5638 >= D.5639;
  D.5641 = (long int) D.5640;
  D.5642 = __builtin_expect (D.5641, 0);
  if (D.5642 != 0) goto <D.5643>; else goto <D.5644>;
  <D.5643>:
  D.5638 = pool->pos;
  D.5636 = (sizetype) size;
  D.5645 = -D.5636;
  D.5646 = D.5638 + D.5645;
  pool->pos = D.5646;
  if (size > 4095) goto <D.5647>; else goto <D.5648>;
  <D.5647>:
  {
    struct MonoMemPool * np;

    D.5649 = (long unsigned int) size;
    D.5650 = D.5649 + 48;
    np = monoeg_malloc (D.5650);
    D.5651 = pool->next;
    np->next = D.5651;
    pool->next = np;
    D.5652 = np + 48;
    np->pos = D.5652;
    D.5653 = size + 48;
    np->size = D.5653;
    D.5654 = np->pos;
    D.5655 = np->size;
    D.5656 = (sizetype) D.5655;
    D.5657 = D.5656 + 18446744073709551568;
    D.5658 = D.5654 + D.5657;
    np->end = D.5658;
    D.5659 = pool->d.allocated;
    D.5660 = D.5659 + size;
    D.5661 = D.5660 + 48;
    pool->d.allocated = D.5661;
    D.5649 = (long unsigned int) size;
    total_bytes_allocated.5 = total_bytes_allocated;
    total_bytes_allocated.6 = (long unsigned int) total_bytes_allocated.5;
    D.5664 = D.5649 + total_bytes_allocated.6;
    D.5665 = D.5664 + 48;
    total_bytes_allocated.7 = (long int) D.5665;
    total_bytes_allocated = total_bytes_allocated.7;
    D.5667 = np + 48;
    return D.5667;
  }
  <D.5648>:
  {
    int new_size;
    struct MonoMemPool * np;

    size.8 = (int) size;
    new_size = get_next_size (pool, size.8);
    D.5669 = (long unsigned int) new_size;
    np = monoeg_malloc (D.5669);
    D.5651 = pool->next;
    np->next = D.5651;
    pool->next = np;
    D.5670 = np + 48;
    pool->pos = D.5670;
    D.5670 = np + 48;
    np->pos = D.5670;
    new_size.9 = (unsigned int) new_size;
    np->size = new_size.9;
    D.5672 = np->pos;
    np->end = D.5672;
    D.5638 = pool->pos;
    D.5673 = (sizetype) new_size;
    D.5674 = D.5673 + 18446744073709551568;
    D.5675 = D.5638 + D.5674;
    pool->end = D.5675;
    D.5659 = pool->d.allocated;
    new_size.9 = (unsigned int) new_size;
    D.5676 = D.5659 + new_size.9;
    pool->d.allocated = D.5676;
    D.5677 = (long int) new_size;
    total_bytes_allocated.5 = total_bytes_allocated;
    total_bytes_allocated.10 = D.5677 + total_bytes_allocated.5;
    total_bytes_allocated = total_bytes_allocated.10;
    rval = pool->pos;
    D.5638 = pool->pos;
    D.5636 = (sizetype) size;
    D.5679 = D.5638 + D.5636;
    pool->pos = D.5679;
  }
  <D.5644>:
  D.5667 = rval;
  return D.5667;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.11;
  struct MonoMemPool * D.5682;
  unsigned int D.5685;
  unsigned int D.5687;
  unsigned int size.12;
  unsigned int D.5689;
  int D.5690;
  int D.5695;
  int target;

  D.5682 = pool->next;
  if (D.5682 != 0B) goto <D.5683>; else goto <D.5684>;
  <D.5683>:
  D.5682 = pool->next;
  D.5685 = D.5682->size;
  iftmp.11 = (int) D.5685;
  goto <D.5686>;
  <D.5684>:
  D.5687 = pool->size;
  iftmp.11 = (int) D.5687;
  <D.5686>:
  target = iftmp.11;
  size.12 = (unsigned int) size;
  D.5689 = size.12 + 48;
  size = (int) D.5689;
  D.5690 = target / 2;
  target = D.5690 + target;
  goto <D.5549>;
  <D.5548>:
  D.5690 = target / 2;
  target = D.5690 + target;
  <D.5549>:
  if (target < size) goto <D.5548>; else goto <D.5550>;
  <D.5550>:
  if (target > 8192) goto <D.5691>; else goto <D.5692>;
  <D.5691>:
  if (size <= 8192) goto <D.5693>; else goto <D.5694>;
  <D.5693>:
  target = 8192;
  <D.5694>:
  <D.5692>:
  D.5695 = target;
  return D.5695;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5697;
  sizetype D.5698;
  guint8 * D.5699;
  guint8 * D.5700;
  guint8 * D.5701;
  _Bool D.5702;
  long int D.5703;
  long int D.5704;
  long unsigned int D.5707;
  void * D.5708;
  void * rval;

  D.5697 = size + 7;
  size = D.5697 & 4294967288;
  rval = pool->pos;
  D.5698 = (sizetype) size;
  D.5699 = rval + D.5698;
  pool->pos = D.5699;
  D.5700 = pool->pos;
  D.5701 = pool->end;
  D.5702 = D.5700 >= D.5701;
  D.5703 = (long int) D.5702;
  D.5704 = __builtin_expect (D.5703, 0);
  if (D.5704 != 0) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  rval = mono_mempool_alloc (pool, size);
  <D.5706>:
  D.5707 = (long unsigned int) size;
  memset (rval, 0, D.5707);
  D.5708 = rval;
  return D.5708;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.5712;
  sizetype D.5713;
  void * D.5714;
  mono_bool D.5717;
  struct MonoMemPool * p;

  p = pool;
  goto <D.5570>;
  <D.5569>:
  if (addr > p) goto <D.5710>; else goto <D.5711>;
  <D.5710>:
  D.5712 = p->size;
  D.5713 = (sizetype) D.5712;
  D.5714 = p + D.5713;
  if (D.5714 >= addr) goto <D.5715>; else goto <D.5716>;
  <D.5715>:
  D.5717 = 1;
  return D.5717;
  <D.5716>:
  <D.5711>:
  p = p->next;
  <D.5570>:
  if (p != 0B) goto <D.5569>; else goto <D.5571>;
  <D.5571>:
  D.5717 = 0;
  return D.5717;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.5721;
  long unsigned int D.5722;
  int D.5723;
  unsigned int D.5724;
  long unsigned int D.5725;
  int l;
  char * res;

  if (s == 0B) goto <D.5719>; else goto <D.5720>;
  <D.5719>:
  D.5721 = 0B;
  return D.5721;
  <D.5720>:
  D.5722 = strlen (s);
  l = (int) D.5722;
  D.5723 = l + 1;
  D.5724 = (unsigned int) D.5723;
  res = mono_mempool_alloc (pool, D.5724);
  D.5723 = l + 1;
  D.5725 = (long unsigned int) D.5723;
  memcpy (res, s, D.5725);
  D.5721 = res;
  return D.5721;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5727;
  long unsigned int D.5728;

  D.5728 = __builtin_object_size (__dest, 0);
  D.5727 = __builtin___memcpy_chk (__dest, __src, __len, D.5728);
  return D.5727;
}


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

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


mono_mempool_get_bytes_allocated ()
{
  long int D.5732;

  D.5732 = total_bytes_allocated;
  return D.5732;
}