mono_mempool_new ()
{
  struct MonoMemPool * D.4741;

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


mono_mempool_new_size (int initial_size)
{
  unsigned int initial_size.0;
  guint8 * D.4746;
  guint8 * D.4747;
  sizetype initial_size.1;
  sizetype D.4749;
  guint8 * D.4750;
  unsigned int initial_size.2;
  unsigned int D.4752;
  long int total_bytes_allocated.3;
  long int total_bytes_allocated.4;
  struct MonoMemPool * D.4755;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.4743>; else goto <D.4744>;
  <D.4743>:
  initial_size = 512;
  <D.4744>:
  initial_size.0 = (unsigned int) initial_size;
  pool = monoeg_malloc (initial_size.0);
  pool->next = 0B;
  D.4746 = pool + 32;
  pool->pos = D.4746;
  D.4747 = pool->pos;
  initial_size.1 = (sizetype) initial_size;
  D.4749 = initial_size.1 + 4294967264;
  D.4750 = D.4747 + D.4749;
  pool->end = D.4750;
  initial_size.2 = (unsigned int) initial_size;
  pool->size = initial_size.2;
  D.4752 = pool->size;
  pool->d.allocated = D.4752;
  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.4755 = pool;
  return D.4755;
}


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


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

  p = pool;
  goto <D.4685>;
  <D.4684>:
  n = p->next;
  D.4762 = p->size;
  memset (p, 42, D.4762);
  p = n;
  <D.4685>:
  if (p != 0B) goto <D.4684>; else goto <D.4686>;
  <D.4686>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4765;
  int D.4770;
  void * D.4772;
  unsigned int D.4773;

  D.4765 = __builtin_constant_p (__len);
  if (D.4765 != 0) goto <D.4766>; else goto <D.4767>;
  <D.4766>:
  if (__len == 0) goto <D.4768>; else goto <D.4769>;
  <D.4768>:
  D.4770 = __builtin_constant_p (__ch);
  if (D.4770 == 0) goto <D.4763>; else goto <D.4771>;
  <D.4771>:
  if (__ch != 0) goto <D.4763>; else goto <D.4764>;
  <D.4763>:
  __warn_memset_zero_len ();
  D.4772 = __dest;
  return D.4772;
  <D.4764>:
  <D.4769>:
  <D.4767>:
  D.4773 = __builtin_object_size (__dest, 0);
  D.4772 = __builtin___memset_chk (__dest, __ch, __len, D.4773);
  return D.4772;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.4775;
  guint8 * D.4776;
  unsigned int D.4777;
  sizetype D.4778;
  guint8 * D.4779;

  D.4775 = pool + 32;
  pool->pos = D.4775;
  D.4776 = pool->pos;
  D.4777 = pool->size;
  D.4778 = D.4777 + 4294967264;
  D.4779 = D.4776 + D.4778;
  pool->end = D.4779;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.4780;
  int D.4781;
  guint8 * D.4782;
  int D.4783;
  int D.4784;
  unsigned int D.4785;
  unsigned int D.4788;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.4697>;
  <D.4696>:
  D.4780 = p->end;
  D.4781 = (int) D.4780;
  D.4782 = p->pos;
  D.4783 = (int) D.4782;
  D.4784 = D.4781 - D.4783;
  D.4785 = (unsigned int) D.4784;
  still_free = D.4785 + still_free;
  p = p->next;
  count = count + 1;
  <D.4697>:
  if (p != 0B) goto <D.4696>; else goto <D.4698>;
  <D.4698>:
  if (pool != 0B) goto <D.4786>; else goto <D.4787>;
  <D.4786>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.4788 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.4788);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.4787>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.4789;
  guint8 * D.4790;
  guint8 * D.4791;
  guint8 * D.4792;
  _Bool D.4793;
  long int D.4794;
  long int D.4795;
  sizetype D.4798;
  guint8 * D.4799;
  unsigned int D.4802;
  struct MonoMemPool * D.4803;
  guint8 * D.4804;
  guint8 * D.4805;
  unsigned int D.4806;
  sizetype D.4807;
  guint8 * D.4808;
  unsigned int D.4809;
  unsigned int D.4810;
  unsigned int D.4811;
  long int total_bytes_allocated.8;
  long unsigned int total_bytes_allocated.9;
  long unsigned int D.4814;
  long unsigned int D.4815;
  long int total_bytes_allocated.10;
  void * D.4817;
  int size.11;
  unsigned int new_size.12;
  guint8 * D.4820;
  unsigned int new_size.13;
  guint8 * D.4822;
  sizetype new_size.14;
  sizetype D.4824;
  guint8 * D.4825;
  unsigned int D.4826;
  long int total_bytes_allocated.15;
  guint8 * D.4828;
  void * rval;

  D.4789 = size + 7;
  size = D.4789 & 4294967288;
  rval = pool->pos;
  D.4790 = rval + size;
  pool->pos = D.4790;
  D.4791 = pool->pos;
  D.4792 = pool->end;
  D.4793 = D.4791 >= D.4792;
  D.4794 = (long int) D.4793;
  D.4795 = __builtin_expect (D.4794, 0);
  if (D.4795 != 0) goto <D.4796>; else goto <D.4797>;
  <D.4796>:
  D.4791 = pool->pos;
  D.4798 = -size;
  D.4799 = D.4791 + D.4798;
  pool->pos = D.4799;
  if (size > 4095) goto <D.4800>; else goto <D.4801>;
  <D.4800>:
  {
    struct MonoMemPool * np;

    D.4802 = size + 32;
    np = monoeg_malloc (D.4802);
    D.4803 = pool->next;
    np->next = D.4803;
    pool->next = np;
    D.4804 = np + 32;
    np->pos = D.4804;
    D.4802 = size + 32;
    np->size = D.4802;
    D.4805 = np->pos;
    D.4806 = np->size;
    D.4807 = D.4806 + 4294967264;
    D.4808 = D.4805 + D.4807;
    np->end = D.4808;
    D.4809 = pool->d.allocated;
    D.4810 = D.4809 + size;
    D.4811 = D.4810 + 32;
    pool->d.allocated = D.4811;
    total_bytes_allocated.8 = total_bytes_allocated;
    total_bytes_allocated.9 = (long unsigned int) total_bytes_allocated.8;
    D.4814 = size + total_bytes_allocated.9;
    D.4815 = D.4814 + 32;
    total_bytes_allocated.10 = (long int) D.4815;
    total_bytes_allocated = total_bytes_allocated.10;
    D.4817 = np + 32;
    return D.4817;
  }
  <D.4801>:
  {
    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.4803 = pool->next;
    np->next = D.4803;
    pool->next = np;
    D.4820 = np + 32;
    pool->pos = D.4820;
    D.4820 = np + 32;
    np->pos = D.4820;
    new_size.13 = (unsigned int) new_size;
    np->size = new_size.13;
    D.4822 = np->pos;
    np->end = D.4822;
    D.4791 = pool->pos;
    new_size.14 = (sizetype) new_size;
    D.4824 = new_size.14 + 4294967264;
    D.4825 = D.4791 + D.4824;
    pool->end = D.4825;
    D.4809 = pool->d.allocated;
    new_size.13 = (unsigned int) new_size;
    D.4826 = D.4809 + new_size.13;
    pool->d.allocated = D.4826;
    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.4791 = pool->pos;
    D.4828 = D.4791 + size;
    pool->pos = D.4828;
  }
  <D.4797>:
  D.4817 = rval;
  return D.4817;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.16;
  struct MonoMemPool * D.4831;
  unsigned int D.4834;
  unsigned int D.4836;
  unsigned int size.17;
  unsigned int D.4838;
  int D.4839;
  int D.4844;
  int target;

  D.4831 = pool->next;
  if (D.4831 != 0B) goto <D.4832>; else goto <D.4833>;
  <D.4832>:
  D.4831 = pool->next;
  D.4834 = D.4831->size;
  iftmp.16 = (int) D.4834;
  goto <D.4835>;
  <D.4833>:
  D.4836 = pool->size;
  iftmp.16 = (int) D.4836;
  <D.4835>:
  target = iftmp.16;
  size.17 = (unsigned int) size;
  D.4838 = size.17 + 32;
  size = (int) D.4838;
  D.4839 = target / 2;
  target = D.4839 + target;
  goto <D.4705>;
  <D.4704>:
  D.4839 = target / 2;
  target = D.4839 + target;
  <D.4705>:
  if (target < size) goto <D.4704>; else goto <D.4706>;
  <D.4706>:
  if (target > 8192) goto <D.4840>; else goto <D.4841>;
  <D.4840>:
  if (size <= 8192) goto <D.4842>; else goto <D.4843>;
  <D.4842>:
  target = 8192;
  <D.4843>:
  <D.4841>:
  D.4844 = target;
  return D.4844;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.4846;
  guint8 * D.4847;
  guint8 * D.4848;
  guint8 * D.4849;
  _Bool D.4850;
  long int D.4851;
  long int D.4852;
  void * D.4855;
  void * rval;

  D.4846 = size + 7;
  size = D.4846 & 4294967288;
  rval = pool->pos;
  D.4847 = rval + size;
  pool->pos = D.4847;
  D.4848 = pool->pos;
  D.4849 = pool->end;
  D.4850 = D.4848 >= D.4849;
  D.4851 = (long int) D.4850;
  D.4852 = __builtin_expect (D.4851, 0);
  if (D.4852 != 0) goto <D.4853>; else goto <D.4854>;
  <D.4853>:
  rval = mono_mempool_alloc (pool, size);
  <D.4854>:
  memset (rval, 0, size);
  D.4855 = rval;
  return D.4855;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.4859;
  void * D.4860;
  mono_bool D.4863;
  struct MonoMemPool * p;

  p = pool;
  goto <D.4726>;
  <D.4725>:
  if (addr > p) goto <D.4857>; else goto <D.4858>;
  <D.4857>:
  D.4859 = p->size;
  D.4860 = p + D.4859;
  if (D.4860 >= addr) goto <D.4861>; else goto <D.4862>;
  <D.4861>:
  D.4863 = 1;
  return D.4863;
  <D.4862>:
  <D.4858>:
  p = p->next;
  <D.4726>:
  if (p != 0B) goto <D.4725>; else goto <D.4727>;
  <D.4727>:
  D.4863 = 0;
  return D.4863;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.4867;
  unsigned int D.4868;
  int D.4869;
  unsigned int D.4870;
  unsigned int D.4871;
  int l;
  char * res;

  if (s == 0B) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  D.4867 = 0B;
  return D.4867;
  <D.4866>:
  D.4868 = strlen (s);
  l = (int) D.4868;
  D.4869 = l + 1;
  D.4870 = (unsigned int) D.4869;
  res = mono_mempool_alloc (pool, D.4870);
  D.4869 = l + 1;
  D.4871 = (unsigned int) D.4869;
  memcpy (res, s, D.4871);
  D.4867 = res;
  return D.4867;
}


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

  D.4874 = __builtin_object_size (__dest, 0);
  D.4873 = __builtin___memcpy_chk (__dest, __src, __len, D.4874);
  return D.4873;
}


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

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


mono_mempool_get_bytes_allocated ()
{
  long int D.4878;

  D.4878 = total_bytes_allocated;
  return D.4878;
}