mono_mempool_new ()
{
  struct MonoMemPool * D.5071;

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


mono_mempool_new_size (int initial_size)
{
  long unsigned int D.5075;
  guint8 * D.5076;
  guint8 * D.5077;
  sizetype D.5078;
  sizetype D.5079;
  guint8 * D.5080;
  unsigned int initial_size.0;
  unsigned int D.5082;
  long int D.5083;
  long int total_bytes_allocated.1;
  long int total_bytes_allocated.2;
  struct MonoMemPool * D.5086;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.5073>; else goto <D.5074>;
  <D.5073>:
  initial_size = 512;
  <D.5074>:
  D.5075 = (long unsigned int) initial_size;
  pool = monoeg_malloc (D.5075);
  pool->next = 0B;
  D.5076 = pool + 48;
  pool->pos = D.5076;
  D.5077 = pool->pos;
  D.5078 = (sizetype) initial_size;
  D.5079 = D.5078 + 18446744073709551568;
  D.5080 = D.5077 + D.5079;
  pool->end = D.5080;
  initial_size.0 = (unsigned int) initial_size;
  pool->size = initial_size.0;
  D.5082 = pool->size;
  pool->d.allocated = D.5082;
  D.5083 = (long int) initial_size;
  total_bytes_allocated.1 = total_bytes_allocated;
  total_bytes_allocated.2 = D.5083 + total_bytes_allocated.1;
  total_bytes_allocated = total_bytes_allocated.2;
  D.5086 = pool;
  return D.5086;
}


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

  total_bytes_allocated.3 = total_bytes_allocated;
  D.5089 = pool->d.allocated;
  D.5090 = (long int) D.5089;
  total_bytes_allocated.4 = total_bytes_allocated.3 - D.5090;
  total_bytes_allocated = total_bytes_allocated.4;
  p = pool;
  goto <D.5007>;
  <D.5006>:
  n = p->next;
  monoeg_g_free (p);
  p = n;
  <D.5007>:
  if (p != 0B) goto <D.5006>; else goto <D.5008>;
  <D.5008>:
}


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

  p = pool;
  goto <D.5015>;
  <D.5014>:
  n = p->next;
  D.5092 = p->size;
  D.5093 = (long unsigned int) D.5092;
  memset (p, 42, D.5093);
  p = n;
  <D.5015>:
  if (p != 0B) goto <D.5014>; else goto <D.5016>;
  <D.5016>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5096;
  int D.5101;
  void * D.5103;
  long unsigned int D.5104;

  D.5096 = __builtin_constant_p (__len);
  if (D.5096 != 0) goto <D.5097>; else goto <D.5098>;
  <D.5097>:
  if (__len == 0) goto <D.5099>; else goto <D.5100>;
  <D.5099>:
  D.5101 = __builtin_constant_p (__ch);
  if (D.5101 == 0) goto <D.5094>; else goto <D.5102>;
  <D.5102>:
  if (__ch != 0) goto <D.5094>; else goto <D.5095>;
  <D.5094>:
  __warn_memset_zero_len ();
  D.5103 = __dest;
  return D.5103;
  <D.5095>:
  <D.5100>:
  <D.5098>:
  D.5104 = __builtin_object_size (__dest, 0);
  D.5103 = __builtin___memset_chk (__dest, __ch, __len, D.5104);
  return D.5103;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.5106;
  guint8 * D.5107;
  unsigned int D.5108;
  sizetype D.5109;
  sizetype D.5110;
  guint8 * D.5111;

  D.5106 = pool + 48;
  pool->pos = D.5106;
  D.5107 = pool->pos;
  D.5108 = pool->size;
  D.5109 = (sizetype) D.5108;
  D.5110 = D.5109 + 18446744073709551568;
  D.5111 = D.5107 + D.5110;
  pool->end = D.5111;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.5112;
  long int D.5113;
  guint8 * D.5114;
  long int D.5115;
  long int D.5116;
  unsigned int D.5117;
  unsigned int D.5120;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.5027>;
  <D.5026>:
  D.5112 = p->end;
  D.5113 = (long int) D.5112;
  D.5114 = p->pos;
  D.5115 = (long int) D.5114;
  D.5116 = D.5113 - D.5115;
  D.5117 = (unsigned int) D.5116;
  still_free = D.5117 + still_free;
  p = p->next;
  count = count + 1;
  <D.5027>:
  if (p != 0B) goto <D.5026>; else goto <D.5028>;
  <D.5028>:
  if (pool != 0B) goto <D.5118>; else goto <D.5119>;
  <D.5118>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.5120 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.5120);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.5119>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5121;
  sizetype D.5122;
  guint8 * D.5123;
  guint8 * D.5124;
  guint8 * D.5125;
  _Bool D.5126;
  long int D.5127;
  long int D.5128;
  sizetype D.5131;
  guint8 * D.5132;
  long unsigned int D.5135;
  long unsigned int D.5136;
  struct MonoMemPool * D.5137;
  guint8 * D.5138;
  unsigned int D.5139;
  guint8 * D.5140;
  unsigned int D.5141;
  sizetype D.5142;
  sizetype D.5143;
  guint8 * D.5144;
  unsigned int D.5145;
  unsigned int D.5146;
  unsigned int D.5147;
  long int total_bytes_allocated.5;
  long unsigned int total_bytes_allocated.6;
  long unsigned int D.5150;
  long unsigned int D.5151;
  long int total_bytes_allocated.7;
  void * D.5153;
  int size.8;
  long unsigned int D.5155;
  guint8 * D.5156;
  unsigned int new_size.9;
  guint8 * D.5158;
  sizetype D.5159;
  sizetype D.5160;
  guint8 * D.5161;
  unsigned int D.5162;
  long int D.5163;
  long int total_bytes_allocated.10;
  guint8 * D.5165;
  void * rval;

  D.5121 = size + 7;
  size = D.5121 & 4294967288;
  rval = pool->pos;
  D.5122 = (sizetype) size;
  D.5123 = rval + D.5122;
  pool->pos = D.5123;
  D.5124 = pool->pos;
  D.5125 = pool->end;
  D.5126 = D.5124 >= D.5125;
  D.5127 = (long int) D.5126;
  D.5128 = __builtin_expect (D.5127, 0);
  if (D.5128 != 0) goto <D.5129>; else goto <D.5130>;
  <D.5129>:
  D.5124 = pool->pos;
  D.5122 = (sizetype) size;
  D.5131 = -D.5122;
  D.5132 = D.5124 + D.5131;
  pool->pos = D.5132;
  if (size > 4095) goto <D.5133>; else goto <D.5134>;
  <D.5133>:
  {
    struct MonoMemPool * np;

    D.5135 = (long unsigned int) size;
    D.5136 = D.5135 + 48;
    np = monoeg_malloc (D.5136);
    D.5137 = pool->next;
    np->next = D.5137;
    pool->next = np;
    D.5138 = np + 48;
    np->pos = D.5138;
    D.5139 = size + 48;
    np->size = D.5139;
    D.5140 = np->pos;
    D.5141 = np->size;
    D.5142 = (sizetype) D.5141;
    D.5143 = D.5142 + 18446744073709551568;
    D.5144 = D.5140 + D.5143;
    np->end = D.5144;
    D.5145 = pool->d.allocated;
    D.5146 = D.5145 + size;
    D.5147 = D.5146 + 48;
    pool->d.allocated = D.5147;
    D.5135 = (long unsigned int) size;
    total_bytes_allocated.5 = total_bytes_allocated;
    total_bytes_allocated.6 = (long unsigned int) total_bytes_allocated.5;
    D.5150 = D.5135 + total_bytes_allocated.6;
    D.5151 = D.5150 + 48;
    total_bytes_allocated.7 = (long int) D.5151;
    total_bytes_allocated = total_bytes_allocated.7;
    D.5153 = np + 48;
    return D.5153;
  }
  <D.5134>:
  {
    int new_size;
    struct MonoMemPool * np;

    size.8 = (int) size;
    new_size = get_next_size (pool, size.8);
    D.5155 = (long unsigned int) new_size;
    np = monoeg_malloc (D.5155);
    D.5137 = pool->next;
    np->next = D.5137;
    pool->next = np;
    D.5156 = np + 48;
    pool->pos = D.5156;
    D.5156 = np + 48;
    np->pos = D.5156;
    new_size.9 = (unsigned int) new_size;
    np->size = new_size.9;
    D.5158 = np->pos;
    np->end = D.5158;
    D.5124 = pool->pos;
    D.5159 = (sizetype) new_size;
    D.5160 = D.5159 + 18446744073709551568;
    D.5161 = D.5124 + D.5160;
    pool->end = D.5161;
    D.5145 = pool->d.allocated;
    new_size.9 = (unsigned int) new_size;
    D.5162 = D.5145 + new_size.9;
    pool->d.allocated = D.5162;
    D.5163 = (long int) new_size;
    total_bytes_allocated.5 = total_bytes_allocated;
    total_bytes_allocated.10 = D.5163 + total_bytes_allocated.5;
    total_bytes_allocated = total_bytes_allocated.10;
    rval = pool->pos;
    D.5124 = pool->pos;
    D.5122 = (sizetype) size;
    D.5165 = D.5124 + D.5122;
    pool->pos = D.5165;
  }
  <D.5130>:
  D.5153 = rval;
  return D.5153;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.11;
  struct MonoMemPool * D.5168;
  unsigned int D.5171;
  unsigned int D.5173;
  unsigned int size.12;
  unsigned int D.5175;
  int D.5176;
  _Bool D.5177;
  _Bool D.5178;
  _Bool D.5179;
  int D.5182;
  int target;

  D.5168 = pool->next;
  if (D.5168 != 0B) goto <D.5169>; else goto <D.5170>;
  <D.5169>:
  D.5168 = pool->next;
  D.5171 = D.5168->size;
  iftmp.11 = (int) D.5171;
  goto <D.5172>;
  <D.5170>:
  D.5173 = pool->size;
  iftmp.11 = (int) D.5173;
  <D.5172>:
  target = iftmp.11;
  size.12 = (unsigned int) size;
  D.5175 = size.12 + 48;
  size = (int) D.5175;
  D.5176 = target / 2;
  target = D.5176 + target;
  goto <D.5035>;
  <D.5034>:
  D.5176 = target / 2;
  target = D.5176 + target;
  <D.5035>:
  if (target < size) goto <D.5034>; else goto <D.5036>;
  <D.5036>:
  D.5177 = target > 8192;
  D.5178 = size <= 8192;
  D.5179 = D.5177 & D.5178;
  if (D.5179 != 0) goto <D.5180>; else goto <D.5181>;
  <D.5180>:
  target = 8192;
  <D.5181>:
  D.5182 = target;
  return D.5182;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5184;
  sizetype D.5185;
  guint8 * D.5186;
  guint8 * D.5187;
  guint8 * D.5188;
  _Bool D.5189;
  long int D.5190;
  long int D.5191;
  long unsigned int D.5194;
  void * D.5195;
  void * rval;

  D.5184 = size + 7;
  size = D.5184 & 4294967288;
  rval = pool->pos;
  D.5185 = (sizetype) size;
  D.5186 = rval + D.5185;
  pool->pos = D.5186;
  D.5187 = pool->pos;
  D.5188 = pool->end;
  D.5189 = D.5187 >= D.5188;
  D.5190 = (long int) D.5189;
  D.5191 = __builtin_expect (D.5190, 0);
  if (D.5191 != 0) goto <D.5192>; else goto <D.5193>;
  <D.5192>:
  rval = mono_mempool_alloc (pool, size);
  <D.5193>:
  D.5194 = (long unsigned int) size;
  memset (rval, 0, D.5194);
  D.5195 = rval;
  return D.5195;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.5199;
  sizetype D.5200;
  void * D.5201;
  mono_bool D.5204;
  struct MonoMemPool * p;

  p = pool;
  goto <D.5056>;
  <D.5055>:
  if (addr > p) goto <D.5197>; else goto <D.5198>;
  <D.5197>:
  D.5199 = p->size;
  D.5200 = (sizetype) D.5199;
  D.5201 = p + D.5200;
  if (D.5201 >= addr) goto <D.5202>; else goto <D.5203>;
  <D.5202>:
  D.5204 = 1;
  return D.5204;
  <D.5203>:
  <D.5198>:
  p = p->next;
  <D.5056>:
  if (p != 0B) goto <D.5055>; else goto <D.5057>;
  <D.5057>:
  D.5204 = 0;
  return D.5204;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.5208;
  long unsigned int D.5209;
  int D.5210;
  unsigned int D.5211;
  long unsigned int D.5212;
  int l;
  char * res;

  if (s == 0B) goto <D.5206>; else goto <D.5207>;
  <D.5206>:
  D.5208 = 0B;
  return D.5208;
  <D.5207>:
  D.5209 = strlen (s);
  l = (int) D.5209;
  D.5210 = l + 1;
  D.5211 = (unsigned int) D.5210;
  res = mono_mempool_alloc (pool, D.5211);
  D.5210 = l + 1;
  D.5212 = (long unsigned int) D.5210;
  memcpy (res, s, D.5212);
  D.5208 = res;
  return D.5208;
}


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

  D.5215 = __builtin_object_size (__dest, 0);
  D.5214 = __builtin___memcpy_chk (__dest, __src, __len, D.5215);
  return D.5214;
}


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

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


mono_mempool_get_bytes_allocated ()
{
  long int D.5219;

  D.5219 = total_bytes_allocated;
  return D.5219;
}