mono_mempool_new ()
{
  struct MonoMemPool * D.4721;

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


mono_mempool_new_size (int initial_size)
{
  unsigned int initial_size.0;
  guint8 * D.4726;
  guint8 * D.4727;
  sizetype initial_size.1;
  sizetype D.4729;
  guint8 * D.4730;
  unsigned int initial_size.2;
  unsigned int D.4732;
  long int total_bytes_allocated.3;
  long int total_bytes_allocated.4;
  struct MonoMemPool * D.4735;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.4723>; else goto <D.4724>;
  <D.4723>:
  initial_size = 512;
  <D.4724>:
  initial_size.0 = (unsigned int) initial_size;
  pool = monoeg_malloc (initial_size.0);
  pool->next = 0B;
  D.4726 = pool + 28;
  pool->pos = D.4726;
  D.4727 = pool->pos;
  initial_size.1 = (sizetype) initial_size;
  D.4729 = initial_size.1 + 4294967268;
  D.4730 = D.4727 + D.4729;
  pool->end = D.4730;
  initial_size.2 = (unsigned int) initial_size;
  pool->size = initial_size.2;
  D.4732 = pool->size;
  pool->d.allocated = D.4732;
  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.4735 = pool;
  return D.4735;
}


mono_mempool_destroy (struct MonoMemPool * pool)
{
  long int total_bytes_allocated.5;
  long unsigned int total_bytes_allocated.6;
  unsigned int D.4739;
  long unsigned int D.4740;
  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.4739 = pool->d.allocated;
  D.4740 = total_bytes_allocated.6 - D.4739;
  total_bytes_allocated.7 = (long int) D.4740;
  total_bytes_allocated = total_bytes_allocated.7;
  p = pool;
  goto <D.4657>;
  <D.4656>:
  n = p->next;
  monoeg_g_free (p);
  p = n;
  <D.4657>:
  if (p != 0B) goto <D.4656>; else goto <D.4658>;
  <D.4658>:
}


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

  p = pool;
  goto <D.4665>;
  <D.4664>:
  n = p->next;
  D.4742 = p->size;
  memset (p, 42, D.4742);
  p = n;
  <D.4665>:
  if (p != 0B) goto <D.4664>; else goto <D.4666>;
  <D.4666>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4745;
  int D.4750;
  void * D.4752;
  unsigned int D.4753;

  D.4745 = __builtin_constant_p (__len);
  if (D.4745 != 0) goto <D.4746>; else goto <D.4747>;
  <D.4746>:
  if (__len == 0) goto <D.4748>; else goto <D.4749>;
  <D.4748>:
  D.4750 = __builtin_constant_p (__ch);
  if (D.4750 == 0) goto <D.4743>; else goto <D.4751>;
  <D.4751>:
  if (__ch != 0) goto <D.4743>; else goto <D.4744>;
  <D.4743>:
  __warn_memset_zero_len ();
  D.4752 = __dest;
  return D.4752;
  <D.4744>:
  <D.4749>:
  <D.4747>:
  D.4753 = __builtin_object_size (__dest, 0);
  D.4752 = __builtin___memset_chk (__dest, __ch, __len, D.4753);
  return D.4752;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.4755;
  guint8 * D.4756;
  unsigned int D.4757;
  sizetype D.4758;
  guint8 * D.4759;

  D.4755 = pool + 28;
  pool->pos = D.4755;
  D.4756 = pool->pos;
  D.4757 = pool->size;
  D.4758 = D.4757 + 4294967268;
  D.4759 = D.4756 + D.4758;
  pool->end = D.4759;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.4760;
  int D.4761;
  guint8 * D.4762;
  int D.4763;
  int D.4764;
  unsigned int D.4765;
  unsigned int D.4768;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.4677>;
  <D.4676>:
  D.4760 = p->end;
  D.4761 = (int) D.4760;
  D.4762 = p->pos;
  D.4763 = (int) D.4762;
  D.4764 = D.4761 - D.4763;
  D.4765 = (unsigned int) D.4764;
  still_free = D.4765 + still_free;
  p = p->next;
  count = count + 1;
  <D.4677>:
  if (p != 0B) goto <D.4676>; else goto <D.4678>;
  <D.4678>:
  if (pool != 0B) goto <D.4766>; else goto <D.4767>;
  <D.4766>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.4768 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.4768);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.4767>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.4769;
  guint8 * D.4770;
  guint8 * D.4771;
  guint8 * D.4772;
  _Bool D.4773;
  long int D.4774;
  long int D.4775;
  sizetype D.4778;
  guint8 * D.4779;
  unsigned int D.4782;
  struct MonoMemPool * D.4783;
  guint8 * D.4784;
  guint8 * D.4785;
  unsigned int D.4786;
  sizetype D.4787;
  guint8 * D.4788;
  unsigned int D.4789;
  unsigned int D.4790;
  unsigned int D.4791;
  long int total_bytes_allocated.8;
  long unsigned int total_bytes_allocated.9;
  long unsigned int D.4794;
  long unsigned int D.4795;
  long int total_bytes_allocated.10;
  void * D.4797;
  int size.11;
  unsigned int new_size.12;
  guint8 * D.4800;
  unsigned int new_size.13;
  guint8 * D.4802;
  sizetype new_size.14;
  sizetype D.4804;
  guint8 * D.4805;
  unsigned int D.4806;
  long int total_bytes_allocated.15;
  guint8 * D.4808;
  void * rval;

  D.4769 = size + 7;
  size = D.4769 & 4294967288;
  rval = pool->pos;
  D.4770 = rval + size;
  pool->pos = D.4770;
  D.4771 = pool->pos;
  D.4772 = pool->end;
  D.4773 = D.4771 >= D.4772;
  D.4774 = (long int) D.4773;
  D.4775 = __builtin_expect (D.4774, 0);
  if (D.4775 != 0) goto <D.4776>; else goto <D.4777>;
  <D.4776>:
  D.4771 = pool->pos;
  D.4778 = -size;
  D.4779 = D.4771 + D.4778;
  pool->pos = D.4779;
  if (size > 4095) goto <D.4780>; else goto <D.4781>;
  <D.4780>:
  {
    struct MonoMemPool * np;

    D.4782 = size + 28;
    np = monoeg_malloc (D.4782);
    D.4783 = pool->next;
    np->next = D.4783;
    pool->next = np;
    D.4784 = np + 28;
    np->pos = D.4784;
    D.4782 = size + 28;
    np->size = D.4782;
    D.4785 = np->pos;
    D.4786 = np->size;
    D.4787 = D.4786 + 4294967268;
    D.4788 = D.4785 + D.4787;
    np->end = D.4788;
    D.4789 = pool->d.allocated;
    D.4790 = D.4789 + size;
    D.4791 = D.4790 + 28;
    pool->d.allocated = D.4791;
    total_bytes_allocated.8 = total_bytes_allocated;
    total_bytes_allocated.9 = (long unsigned int) total_bytes_allocated.8;
    D.4794 = size + total_bytes_allocated.9;
    D.4795 = D.4794 + 28;
    total_bytes_allocated.10 = (long int) D.4795;
    total_bytes_allocated = total_bytes_allocated.10;
    D.4797 = np + 28;
    return D.4797;
  }
  <D.4781>:
  {
    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.4783 = pool->next;
    np->next = D.4783;
    pool->next = np;
    D.4800 = np + 28;
    pool->pos = D.4800;
    D.4800 = np + 28;
    np->pos = D.4800;
    new_size.13 = (unsigned int) new_size;
    np->size = new_size.13;
    D.4802 = np->pos;
    np->end = D.4802;
    D.4771 = pool->pos;
    new_size.14 = (sizetype) new_size;
    D.4804 = new_size.14 + 4294967268;
    D.4805 = D.4771 + D.4804;
    pool->end = D.4805;
    D.4789 = pool->d.allocated;
    new_size.13 = (unsigned int) new_size;
    D.4806 = D.4789 + new_size.13;
    pool->d.allocated = D.4806;
    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.4771 = pool->pos;
    D.4808 = D.4771 + size;
    pool->pos = D.4808;
  }
  <D.4777>:
  D.4797 = rval;
  return D.4797;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.16;
  struct MonoMemPool * D.4811;
  unsigned int D.4814;
  unsigned int D.4816;
  unsigned int size.17;
  unsigned int D.4818;
  int D.4819;
  _Bool D.4820;
  _Bool D.4821;
  _Bool D.4822;
  int D.4825;
  int target;

  D.4811 = pool->next;
  if (D.4811 != 0B) goto <D.4812>; else goto <D.4813>;
  <D.4812>:
  D.4811 = pool->next;
  D.4814 = D.4811->size;
  iftmp.16 = (int) D.4814;
  goto <D.4815>;
  <D.4813>:
  D.4816 = pool->size;
  iftmp.16 = (int) D.4816;
  <D.4815>:
  target = iftmp.16;
  size.17 = (unsigned int) size;
  D.4818 = size.17 + 28;
  size = (int) D.4818;
  D.4819 = target / 2;
  target = D.4819 + target;
  goto <D.4685>;
  <D.4684>:
  D.4819 = target / 2;
  target = D.4819 + target;
  <D.4685>:
  if (target < size) goto <D.4684>; else goto <D.4686>;
  <D.4686>:
  D.4820 = target > 8192;
  D.4821 = size <= 8192;
  D.4822 = D.4820 & D.4821;
  if (D.4822 != 0) goto <D.4823>; else goto <D.4824>;
  <D.4823>:
  target = 8192;
  <D.4824>:
  D.4825 = target;
  return D.4825;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.4827;
  guint8 * D.4828;
  guint8 * D.4829;
  guint8 * D.4830;
  _Bool D.4831;
  long int D.4832;
  long int D.4833;
  void * D.4836;
  void * rval;

  D.4827 = size + 7;
  size = D.4827 & 4294967288;
  rval = pool->pos;
  D.4828 = rval + size;
  pool->pos = D.4828;
  D.4829 = pool->pos;
  D.4830 = pool->end;
  D.4831 = D.4829 >= D.4830;
  D.4832 = (long int) D.4831;
  D.4833 = __builtin_expect (D.4832, 0);
  if (D.4833 != 0) goto <D.4834>; else goto <D.4835>;
  <D.4834>:
  rval = mono_mempool_alloc (pool, size);
  <D.4835>:
  memset (rval, 0, size);
  D.4836 = rval;
  return D.4836;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.4840;
  void * D.4841;
  mono_bool D.4844;
  struct MonoMemPool * p;

  p = pool;
  goto <D.4706>;
  <D.4705>:
  if (addr > p) goto <D.4838>; else goto <D.4839>;
  <D.4838>:
  D.4840 = p->size;
  D.4841 = p + D.4840;
  if (D.4841 >= addr) goto <D.4842>; else goto <D.4843>;
  <D.4842>:
  D.4844 = 1;
  return D.4844;
  <D.4843>:
  <D.4839>:
  p = p->next;
  <D.4706>:
  if (p != 0B) goto <D.4705>; else goto <D.4707>;
  <D.4707>:
  D.4844 = 0;
  return D.4844;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.4848;
  unsigned int D.4849;
  int D.4850;
  unsigned int D.4851;
  unsigned int D.4852;
  int l;
  char * res;

  if (s == 0B) goto <D.4846>; else goto <D.4847>;
  <D.4846>:
  D.4848 = 0B;
  return D.4848;
  <D.4847>:
  D.4849 = strlen (s);
  l = (int) D.4849;
  D.4850 = l + 1;
  D.4851 = (unsigned int) D.4850;
  res = mono_mempool_alloc (pool, D.4851);
  D.4850 = l + 1;
  D.4852 = (unsigned int) D.4850;
  memcpy (res, s, D.4852);
  D.4848 = res;
  return D.4848;
}


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

  D.4855 = __builtin_object_size (__dest, 0);
  D.4854 = __builtin___memcpy_chk (__dest, __src, __len, D.4855);
  return D.4854;
}


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

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


mono_mempool_get_bytes_allocated ()
{
  long int D.4859;

  D.4859 = total_bytes_allocated;
  return D.4859;
}