mono_mempool_new ()
{
  struct MonoMemPool * D.5238;

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


mono_mempool_new_size (int initial_size)
{
  long unsigned int D.5242;
  guint8 * D.5243;
  guint8 * D.5244;
  sizetype D.5245;
  sizetype D.5246;
  guint8 * D.5247;
  unsigned int initial_size.0;
  unsigned int D.5249;
  long int D.5250;
  long int total_bytes_allocated.1;
  long int D.5252;
  struct MonoMemPool * D.5253;
  struct MonoMemPool * pool;

  if (initial_size <= 511) goto <D.5240>; else goto <D.5241>;
  <D.5240>:
  initial_size = 512;
  <D.5241>:
  D.5242 = (long unsigned int) initial_size;
  pool = monoeg_malloc (D.5242);
  pool->next = 0B;
  D.5243 = pool + 48;
  pool->pos = D.5243;
  D.5244 = pool->pos;
  D.5245 = (sizetype) initial_size;
  D.5246 = D.5245 + 18446744073709551568;
  D.5247 = D.5244 + D.5246;
  pool->end = D.5247;
  initial_size.0 = (unsigned int) initial_size;
  pool->size = initial_size.0;
  D.5249 = pool->size;
  pool->d.allocated = D.5249;
  D.5250 = (long int) initial_size;
  total_bytes_allocated.1 = total_bytes_allocated;
  D.5252 = D.5250 + total_bytes_allocated.1;
  total_bytes_allocated = D.5252;
  D.5253 = pool;
  return D.5253;
}


mono_mempool_destroy (struct MonoMemPool * pool)
{
  long int total_bytes_allocated.2;
  unsigned int D.5256;
  long int D.5257;
  long int D.5258;
  struct MonoMemPool * p;
  struct MonoMemPool * n;

  total_bytes_allocated.2 = total_bytes_allocated;
  D.5256 = pool->d.allocated;
  D.5257 = (long int) D.5256;
  D.5258 = total_bytes_allocated.2 - D.5257;
  total_bytes_allocated = D.5258;
  p = pool;
  goto <D.5174>;
  <D.5173>:
  n = p->next;
  monoeg_g_free (p);
  p = n;
  <D.5174>:
  if (p != 0B) goto <D.5173>; else goto <D.5175>;
  <D.5175>:
}


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

  p = pool;
  goto <D.5182>;
  <D.5181>:
  n = p->next;
  D.5259 = p->size;
  D.5260 = (long unsigned int) D.5259;
  memset (p, 42, D.5260);
  p = n;
  <D.5182>:
  if (p != 0B) goto <D.5181>; else goto <D.5183>;
  <D.5183>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.5261;
  long unsigned int D.5262;

  D.5262 = __builtin_object_size (__dest, 0);
  D.5261 = __builtin___memset_chk (__dest, __ch, __len, D.5262);
  return D.5261;
}


mono_mempool_empty (struct MonoMemPool * pool)
{
  guint8 * D.5264;
  guint8 * D.5265;
  unsigned int D.5266;
  sizetype D.5267;
  sizetype D.5268;
  guint8 * D.5269;

  D.5264 = pool + 48;
  pool->pos = D.5264;
  D.5265 = pool->pos;
  D.5266 = pool->size;
  D.5267 = (sizetype) D.5266;
  D.5268 = D.5267 + 18446744073709551568;
  D.5269 = D.5265 + D.5268;
  pool->end = D.5269;
}


mono_mempool_stats (struct MonoMemPool * pool)
{
  guint8 * D.5270;
  long int D.5271;
  guint8 * D.5272;
  long int D.5273;
  long int D.5274;
  unsigned int D.5275;
  unsigned int D.5278;
  struct MonoMemPool * p;
  int count;
  guint32 still_free;

  count = 0;
  still_free = 0;
  p = pool;
  goto <D.5194>;
  <D.5193>:
  D.5270 = p->end;
  D.5271 = (long int) D.5270;
  D.5272 = p->pos;
  D.5273 = (long int) D.5272;
  D.5274 = D.5271 - D.5273;
  D.5275 = (unsigned int) D.5274;
  still_free = D.5275 + still_free;
  p = p->next;
  count = count + 1;
  <D.5194>:
  if (p != 0B) goto <D.5193>; else goto <D.5195>;
  <D.5195>:
  if (pool != 0B) goto <D.5276>; else goto <D.5277>;
  <D.5276>:
  monoeg_g_print ("Mempool %p stats:\n", pool);
  D.5278 = pool->d.allocated;
  monoeg_g_print ("Total mem allocated: %d\n", D.5278);
  monoeg_g_print ("Num chunks: %d\n", count);
  monoeg_g_print ("Free memory: %d\n", still_free);
  <D.5277>:
}


mono_mempool_alloc (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5279;
  sizetype D.5280;
  guint8 * D.5281;
  guint8 * D.5282;
  guint8 * D.5283;
  _Bool D.5284;
  long int D.5285;
  long int D.5286;
  sizetype D.5289;
  guint8 * D.5290;
  long unsigned int D.5293;
  long unsigned int D.5294;
  struct MonoMemPool * D.5295;
  guint8 * D.5296;
  unsigned int D.5297;
  guint8 * D.5298;
  unsigned int D.5299;
  sizetype D.5300;
  sizetype D.5301;
  guint8 * D.5302;
  unsigned int D.5303;
  unsigned int D.5304;
  unsigned int D.5305;
  long int total_bytes_allocated.3;
  long unsigned int total_bytes_allocated.4;
  long unsigned int D.5308;
  long unsigned int D.5309;
  long int D.5310;
  void * D.5311;
  int size.5;
  long unsigned int D.5313;
  guint8 * D.5314;
  unsigned int new_size.6;
  guint8 * D.5316;
  sizetype D.5317;
  sizetype D.5318;
  guint8 * D.5319;
  unsigned int D.5320;
  long int D.5321;
  long int D.5322;
  guint8 * D.5323;
  void * rval;

  D.5279 = size + 7;
  size = D.5279 & 4294967288;
  rval = pool->pos;
  D.5280 = (sizetype) size;
  D.5281 = rval + D.5280;
  pool->pos = D.5281;
  D.5282 = pool->pos;
  D.5283 = pool->end;
  D.5284 = D.5282 >= D.5283;
  D.5285 = (long int) D.5284;
  D.5286 = __builtin_expect (D.5285, 0);
  if (D.5286 != 0) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  D.5282 = pool->pos;
  D.5280 = (sizetype) size;
  D.5289 = -D.5280;
  D.5290 = D.5282 + D.5289;
  pool->pos = D.5290;
  if (size > 4095) goto <D.5291>; else goto <D.5292>;
  <D.5291>:
  {
    struct MonoMemPool * np;

    D.5293 = (long unsigned int) size;
    D.5294 = D.5293 + 48;
    np = monoeg_malloc (D.5294);
    D.5295 = pool->next;
    np->next = D.5295;
    pool->next = np;
    D.5296 = np + 48;
    np->pos = D.5296;
    D.5297 = size + 48;
    np->size = D.5297;
    D.5298 = np->pos;
    D.5299 = np->size;
    D.5300 = (sizetype) D.5299;
    D.5301 = D.5300 + 18446744073709551568;
    D.5302 = D.5298 + D.5301;
    np->end = D.5302;
    D.5303 = pool->d.allocated;
    D.5304 = D.5303 + size;
    D.5305 = D.5304 + 48;
    pool->d.allocated = D.5305;
    D.5293 = (long unsigned int) size;
    total_bytes_allocated.3 = total_bytes_allocated;
    total_bytes_allocated.4 = (long unsigned int) total_bytes_allocated.3;
    D.5308 = D.5293 + total_bytes_allocated.4;
    D.5309 = D.5308 + 48;
    D.5310 = (long int) D.5309;
    total_bytes_allocated = D.5310;
    D.5311 = np + 48;
    return D.5311;
  }
  <D.5292>:
  {
    int new_size;
    struct MonoMemPool * np;

    size.5 = (int) size;
    new_size = get_next_size (pool, size.5);
    D.5313 = (long unsigned int) new_size;
    np = monoeg_malloc (D.5313);
    D.5295 = pool->next;
    np->next = D.5295;
    pool->next = np;
    D.5314 = np + 48;
    pool->pos = D.5314;
    D.5314 = np + 48;
    np->pos = D.5314;
    new_size.6 = (unsigned int) new_size;
    np->size = new_size.6;
    D.5316 = np->pos;
    np->end = D.5316;
    D.5282 = pool->pos;
    D.5317 = (sizetype) new_size;
    D.5318 = D.5317 + 18446744073709551568;
    D.5319 = D.5282 + D.5318;
    pool->end = D.5319;
    D.5303 = pool->d.allocated;
    new_size.6 = (unsigned int) new_size;
    D.5320 = D.5303 + new_size.6;
    pool->d.allocated = D.5320;
    D.5321 = (long int) new_size;
    total_bytes_allocated.3 = total_bytes_allocated;
    D.5322 = D.5321 + total_bytes_allocated.3;
    total_bytes_allocated = D.5322;
    rval = pool->pos;
    D.5282 = pool->pos;
    D.5280 = (sizetype) size;
    D.5323 = D.5282 + D.5280;
    pool->pos = D.5323;
  }
  <D.5288>:
  D.5311 = rval;
  return D.5311;
}


get_next_size (struct MonoMemPool * pool, int size)
{
  int iftmp.7;
  struct MonoMemPool * D.5326;
  unsigned int D.5329;
  unsigned int D.5331;
  unsigned int size.8;
  unsigned int D.5333;
  int D.5334;
  int D.5339;
  int target;

  D.5326 = pool->next;
  if (D.5326 != 0B) goto <D.5327>; else goto <D.5328>;
  <D.5327>:
  D.5326 = pool->next;
  D.5329 = D.5326->size;
  iftmp.7 = (int) D.5329;
  goto <D.5330>;
  <D.5328>:
  D.5331 = pool->size;
  iftmp.7 = (int) D.5331;
  <D.5330>:
  target = iftmp.7;
  size.8 = (unsigned int) size;
  D.5333 = size.8 + 48;
  size = (int) D.5333;
  D.5334 = target / 2;
  target = D.5334 + target;
  goto <D.5202>;
  <D.5201>:
  D.5334 = target / 2;
  target = D.5334 + target;
  <D.5202>:
  if (target < size) goto <D.5201>; else goto <D.5203>;
  <D.5203>:
  if (target > 8192) goto <D.5335>; else goto <D.5336>;
  <D.5335>:
  if (size <= 8192) goto <D.5337>; else goto <D.5338>;
  <D.5337>:
  target = 8192;
  <D.5338>:
  <D.5336>:
  D.5339 = target;
  return D.5339;
}


mono_mempool_alloc0 (struct MonoMemPool * pool, guint size)
{
  unsigned int D.5341;
  sizetype D.5342;
  guint8 * D.5343;
  guint8 * D.5344;
  guint8 * D.5345;
  _Bool D.5346;
  long int D.5347;
  long int D.5348;
  long unsigned int D.5351;
  void * D.5352;
  void * rval;

  D.5341 = size + 7;
  size = D.5341 & 4294967288;
  rval = pool->pos;
  D.5342 = (sizetype) size;
  D.5343 = rval + D.5342;
  pool->pos = D.5343;
  D.5344 = pool->pos;
  D.5345 = pool->end;
  D.5346 = D.5344 >= D.5345;
  D.5347 = (long int) D.5346;
  D.5348 = __builtin_expect (D.5347, 0);
  if (D.5348 != 0) goto <D.5349>; else goto <D.5350>;
  <D.5349>:
  rval = mono_mempool_alloc (pool, size);
  <D.5350>:
  D.5351 = (long unsigned int) size;
  memset (rval, 0, D.5351);
  D.5352 = rval;
  return D.5352;
}


mono_mempool_contains_addr (struct MonoMemPool * pool, void * addr)
{
  unsigned int D.5356;
  sizetype D.5357;
  void * D.5358;
  mono_bool D.5361;
  struct MonoMemPool * p;

  p = pool;
  goto <D.5223>;
  <D.5222>:
  if (addr > p) goto <D.5354>; else goto <D.5355>;
  <D.5354>:
  D.5356 = p->size;
  D.5357 = (sizetype) D.5356;
  D.5358 = p + D.5357;
  if (D.5358 >= addr) goto <D.5359>; else goto <D.5360>;
  <D.5359>:
  D.5361 = 1;
  return D.5361;
  <D.5360>:
  <D.5355>:
  p = p->next;
  <D.5223>:
  if (p != 0B) goto <D.5222>; else goto <D.5224>;
  <D.5224>:
  D.5361 = 0;
  return D.5361;
}


mono_mempool_strdup (struct MonoMemPool * pool, const char * s)
{
  char * D.5365;
  long unsigned int D.5366;
  int D.5367;
  unsigned int D.5368;
  long unsigned int D.5369;
  int l;
  char * res;

  if (s == 0B) goto <D.5363>; else goto <D.5364>;
  <D.5363>:
  D.5365 = 0B;
  return D.5365;
  <D.5364>:
  D.5366 = __strlen_g (s);
  l = (int) D.5366;
  D.5367 = l + 1;
  D.5368 = (unsigned int) D.5367;
  res = mono_mempool_alloc (pool, D.5368);
  D.5367 = l + 1;
  D.5369 = (long unsigned int) D.5367;
  memcpy (res, s, D.5369);
  D.5365 = res;
  return D.5365;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.5371;
  long int __ptr.9;
  long int __str.10;
  long int D.5374;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.9 = (long int) __ptr;
  __str.10 = (long int) __str;
  D.5374 = __ptr.9 - __str.10;
  D.5371 = (size_t) D.5374;
  return D.5371;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5376;
  long unsigned int D.5377;

  D.5377 = __builtin_object_size (__dest, 0);
  D.5376 = __builtin___memcpy_chk (__dest, __src, __len, D.5377);
  return D.5376;
}


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

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


__attribute__((visibility ("hidden")))
mono_mempool_get_bytes_allocated ()
{
  long int D.5381;

  D.5381 = total_bytes_allocated;
  return D.5381;
}