mono_bitset_alloc_size (guint32 max_size, guint32 flags)
{
  long unsigned int D.5391;
  long unsigned int D.5392;
  long unsigned int D.5393;
  guint32 D.5394;
  long unsigned int D.5395;
  long unsigned int D.5396;
  unsigned int D.5397;
  guint32 real_size;

  D.5391 = (long unsigned int) max_size;
  D.5392 = D.5391 + 63;
  D.5393 = D.5392 / 64;
  real_size = (guint32) D.5393;
  D.5395 = (long unsigned int) real_size;
  D.5396 = D.5395 + 2;
  D.5397 = (unsigned int) D.5396;
  D.5394 = D.5397 * 8;
  return D.5394;
}


mono_bitset_new (guint32 max_size, guint32 flags)
{
  long unsigned int D.5399;
  long unsigned int D.5400;
  long unsigned int D.5401;
  long unsigned int D.5402;
  long unsigned int D.5403;
  long unsigned int D.5404;
  long unsigned int D.5405;
  long unsigned int D.5406;
  struct MonoBitSet * D.5407;
  guint32 real_size;
  struct MonoBitSet * result;

  D.5399 = (long unsigned int) max_size;
  D.5400 = D.5399 + 63;
  D.5401 = D.5400 / 64;
  real_size = (guint32) D.5401;
  D.5402 = (long unsigned int) real_size;
  D.5403 = D.5402 + 2;
  D.5404 = D.5403 * 8;
  result = monoeg_malloc0 (D.5404);
  D.5402 = (long unsigned int) real_size;
  D.5405 = D.5402 * 64;
  result->size = D.5405;
  D.5406 = (long unsigned int) flags;
  result->flags = D.5406;
  D.5407 = result;
  return D.5407;
}


mono_bitset_mem_new (void * mem, guint32 max_size, guint32 flags)
{
  long unsigned int D.5409;
  long unsigned int D.5410;
  long unsigned int D.5411;
  long unsigned int D.5412;
  long unsigned int D.5413;
  unsigned int D.5414;
  long unsigned int D.5415;
  struct MonoBitSet * D.5416;
  guint32 real_size;
  struct MonoBitSet * result;

  D.5409 = (long unsigned int) max_size;
  D.5410 = D.5409 + 63;
  D.5411 = D.5410 / 64;
  real_size = (guint32) D.5411;
  result = mem;
  D.5412 = (long unsigned int) real_size;
  D.5413 = D.5412 * 64;
  result->size = D.5413;
  D.5414 = flags | 1;
  D.5415 = (long unsigned int) D.5414;
  result->flags = D.5415;
  D.5416 = result;
  return D.5416;
}


mono_bitset_free (struct MonoBitSet * set)
{
  long unsigned int D.5418;
  long unsigned int D.5419;

  D.5418 = set->flags;
  D.5419 = D.5418 & 1;
  if (D.5419 == 0) goto <D.5420>; else goto <D.5421>;
  <D.5420>:
  monoeg_g_free (set);
  <D.5421>:
}


mono_bitset_set (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5422;
  int pos.0;
  long unsigned int D.5424;
  long unsigned int D.5425;
  _Bool D.5426;
  long int D.5427;
  long int D.5428;
  long unsigned int D.5431;
  long unsigned int D.5432;
  long unsigned int D.5433;
  int j;
  int bit;

  D.5422 = pos / 64;
  j = (int) D.5422;
  pos.0 = (int) pos;
  bit = pos.0 & 63;
  D.5424 = (long unsigned int) pos;
  D.5425 = set->size;
  D.5426 = D.5424 >= D.5425;
  D.5427 = (long int) D.5426;
  D.5428 = __builtin_expect (D.5427, 0);
  if (D.5428 != 0) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 90, "pos < set->size");
  <D.5430>:
  D.5431 = set->data[j];
  D.5432 = 1 << bit;
  D.5433 = D.5431 | D.5432;
  set->data[j] = D.5433;
}


mono_bitset_test (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5434;
  int pos.1;
  long unsigned int D.5436;
  long unsigned int D.5437;
  int D.5440;
  long unsigned int D.5441;
  long unsigned int D.5442;
  long unsigned int D.5443;
  _Bool D.5444;
  int j;
  int bit;

  D.5434 = pos / 64;
  j = (int) D.5434;
  pos.1 = (int) pos;
  bit = pos.1 & 63;
  D.5436 = (long unsigned int) pos;
  D.5437 = set->size;
  if (D.5436 >= D.5437) goto <D.5438>; else goto <D.5439>;
  <D.5438>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 108, "pos < set->size");
  D.5440 = 0;
  return D.5440;
  <D.5439>:
  D.5441 = set->data[j];
  D.5442 = D.5441 >> bit;
  D.5443 = D.5442 & 1;
  D.5444 = D.5443 != 0;
  D.5440 = (int) D.5444;
  return D.5440;
}


mono_bitset_test_bulk (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5446;
  long unsigned int D.5447;
  long unsigned int D.5448;
  gsize D.5451;
  int j;

  D.5446 = pos / 64;
  j = (int) D.5446;
  D.5447 = (long unsigned int) pos;
  D.5448 = set->size;
  if (D.5447 >= D.5448) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  D.5451 = 0;
  return D.5451;
  <D.5450>:
  D.5451 = set->data[j];
  return D.5451;
}


mono_bitset_clear (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5453;
  int pos.2;
  long unsigned int D.5455;
  long unsigned int D.5456;
  _Bool D.5457;
  long int D.5458;
  long int D.5459;
  long unsigned int D.5462;
  long unsigned int D.5463;
  long unsigned int D.5464;
  long unsigned int D.5465;
  int j;
  int bit;

  D.5453 = pos / 64;
  j = (int) D.5453;
  pos.2 = (int) pos;
  bit = pos.2 & 63;
  D.5455 = (long unsigned int) pos;
  D.5456 = set->size;
  D.5457 = D.5455 >= D.5456;
  D.5458 = (long int) D.5457;
  D.5459 = __builtin_expect (D.5458, 0);
  if (D.5459 != 0) goto <D.5460>; else goto <D.5461>;
  <D.5460>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 143, "pos < set->size");
  <D.5461>:
  D.5462 = set->data[j];
  D.5463 = 1 << bit;
  D.5464 = ~D.5463;
  D.5465 = D.5462 & D.5464;
  set->data[j] = D.5465;
}


mono_bitset_clear_all (struct MonoBitSet * set)
{
  gsize[0:] * D.5466;
  long unsigned int D.5467;
  long unsigned int D.5468;

  D.5466 = &set->data;
  D.5467 = set->size;
  D.5468 = D.5467 / 8;
  memset (D.5466, 0, D.5468);
}


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

  D.5470 = __builtin_object_size (__dest, 0);
  D.5469 = __builtin___memset_chk (__dest, __ch, __len, D.5470);
  return D.5469;
}


mono_bitset_set_all (struct MonoBitSet * set)
{
  gsize[0:] * D.5472;
  long unsigned int D.5473;
  long unsigned int D.5474;

  D.5472 = &set->data;
  D.5473 = set->size;
  D.5474 = D.5473 / 8;
  memset (D.5472, -1, D.5474);
}


mono_bitset_invert (struct MonoBitSet * set)
{
  long unsigned int D.5475;
  long unsigned int D.5476;
  long unsigned int D.5477;
  long unsigned int D.5478;
  long unsigned int D.5479;
  int i;

  i = 0;
  goto <D.5239>;
  <D.5238>:
  D.5475 = set->data[i];
  D.5476 = ~D.5475;
  set->data[i] = D.5476;
  i = i + 1;
  <D.5239>:
  D.5477 = (long unsigned int) i;
  D.5478 = set->size;
  D.5479 = D.5478 / 64;
  if (D.5477 < D.5479) goto <D.5238>; else goto <D.5240>;
  <D.5240>:
}


mono_bitset_size (const struct MonoBitSet * set)
{
  guint32 D.5480;
  long unsigned int D.5481;

  D.5481 = set->size;
  D.5480 = (guint32) D.5481;
  return D.5480;
}


mono_bitset_count (const struct MonoBitSet * set)
{
  int D.5485;
  unsigned int D.5486;
  unsigned int D.5488;
  int D.5489;
  unsigned int D.5490;
  long unsigned int D.5491;
  long unsigned int D.5492;
  long unsigned int D.5493;
  guint32 D.5494;
  guint32 i;
  guint32 count;
  gsize d;

  count = 0;
  i = 0;
  goto <D.5251>;
  <D.5250>:
  d = set->data[i];
  if (1 != 0) goto <D.5483>; else goto <D.5484>;
  <D.5483>:
  D.5485 = __builtin_popcountl (d);
  D.5486 = (unsigned int) D.5485;
  count = D.5486 + count;
  goto <D.5487>;
  <D.5484>:
  D.5488 = (unsigned int) d;
  D.5489 = __builtin_popcount (D.5488);
  D.5490 = (unsigned int) D.5489;
  count = D.5490 + count;
  <D.5487>:
  i = i + 1;
  <D.5251>:
  D.5491 = (long unsigned int) i;
  D.5492 = set->size;
  D.5493 = D.5492 / 64;
  if (D.5491 < D.5493) goto <D.5250>; else goto <D.5252>;
  <D.5252>:
  D.5494 = count;
  return D.5494;
}


mono_bitset_find_start (const struct MonoBitSet * set)
{
  long unsigned int D.5496;
  int D.5499;
  int D.5500;
  unsigned int D.5501;
  long unsigned int D.5502;
  unsigned int D.5503;
  unsigned int D.5504;
  unsigned int D.5505;
  long unsigned int D.5506;
  long unsigned int D.5507;
  int i;

  i = 0;
  goto <D.5288>;
  <D.5287>:
  D.5496 = set->data[i];
  if (D.5496 != 0) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  D.5496 = set->data[i];
  D.5500 = my_g_bit_nth_lsf_nomask (D.5496);
  D.5501 = (unsigned int) D.5500;
  D.5502 = (long unsigned int) i;
  D.5503 = (unsigned int) D.5502;
  D.5504 = D.5503 * 64;
  D.5505 = D.5501 + D.5504;
  D.5499 = (int) D.5505;
  return D.5499;
  <D.5498>:
  i = i + 1;
  <D.5288>:
  D.5502 = (long unsigned int) i;
  D.5506 = set->size;
  D.5507 = D.5506 / 64;
  if (D.5502 < D.5507) goto <D.5287>; else goto <D.5289>;
  <D.5289>:
  D.5499 = -1;
  return D.5499;
}


my_g_bit_nth_lsf_nomask (gsize mask)
{
  long unsigned int D.5509;
  gint D.5510;
  int nth_bit;

  nth_bit = 0;
  goto <D.5265>;
  <D.5264>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.5265>:
  D.5509 = mask & 1;
  if (D.5509 == 0) goto <D.5264>; else goto <D.5266>;
  <D.5266>:
  D.5510 = nth_bit;
  return D.5510;
}


mono_bitset_find_first (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5515;
  long unsigned int D.5516;
  long unsigned int D.5517;
  _Bool D.5518;
  long int D.5519;
  long int D.5520;
  long unsigned int D.5523;
  int D.5528;
  long unsigned int D.5529;
  unsigned int D.5530;
  unsigned int D.5531;
  unsigned int result.3;
  unsigned int D.5533;
  long unsigned int D.5534;
  int D.5537;
  unsigned int D.5538;
  long unsigned int D.5539;
  unsigned int D.5540;
  unsigned int D.5541;
  unsigned int D.5542;
  long unsigned int D.5543;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5512>; else goto <D.5513>;
  <D.5512>:
  j = 0;
  bit = -1;
  goto <D.5514>;
  <D.5513>:
  D.5515 = (long unsigned int) pos;
  D.5516 = D.5515 / 64;
  j = (int) D.5516;
  bit = pos & 63;
  D.5515 = (long unsigned int) pos;
  D.5517 = set->size;
  D.5518 = D.5515 >= D.5517;
  D.5519 = (long int) D.5518;
  D.5520 = __builtin_expect (D.5519, 0);
  if (D.5520 != 0) goto <D.5521>; else goto <D.5522>;
  <D.5521>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 424, "pos < set->size");
  <D.5522>:
  <D.5514>:
  D.5523 = set->data[j];
  if (D.5523 != 0) goto <D.5524>; else goto <D.5525>;
  <D.5524>:
  D.5523 = set->data[j];
  result = my_g_bit_nth_lsf (D.5523, bit);
  if (result != -1) goto <D.5526>; else goto <D.5527>;
  <D.5526>:
  D.5529 = (long unsigned int) j;
  D.5530 = (unsigned int) D.5529;
  D.5531 = D.5530 * 64;
  result.3 = (unsigned int) result;
  D.5533 = D.5531 + result.3;
  D.5528 = (int) D.5533;
  return D.5528;
  <D.5527>:
  <D.5525>:
  j = j + 1;
  i = j;
  goto <D.5299>;
  <D.5298>:
  D.5534 = set->data[i];
  if (D.5534 != 0) goto <D.5535>; else goto <D.5536>;
  <D.5535>:
  D.5534 = set->data[i];
  D.5537 = my_g_bit_nth_lsf (D.5534, -1);
  D.5538 = (unsigned int) D.5537;
  D.5539 = (long unsigned int) i;
  D.5540 = (unsigned int) D.5539;
  D.5541 = D.5540 * 64;
  D.5542 = D.5538 + D.5541;
  D.5528 = (int) D.5542;
  return D.5528;
  <D.5536>:
  i = i + 1;
  <D.5299>:
  D.5539 = (long unsigned int) i;
  D.5517 = set->size;
  D.5543 = D.5517 / 64;
  if (D.5539 < D.5543) goto <D.5298>; else goto <D.5300>;
  <D.5300>:
  D.5528 = -1;
  return D.5528;
}


my_g_bit_nth_lsf (gsize mask, gint nth_bit)
{
  gint D.5548;
  long unsigned int D.5549;

  nth_bit = nth_bit + 1;
  mask = mask >> nth_bit;
  if (mask == 0) goto <D.5545>; else goto <D.5547>;
  <D.5547>:
  if (nth_bit == 64) goto <D.5545>; else goto <D.5546>;
  <D.5545>:
  D.5548 = -1;
  return D.5548;
  <D.5546>:
  goto <D.5258>;
  <D.5257>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.5258>:
  D.5549 = mask & 1;
  if (D.5549 == 0) goto <D.5257>; else goto <D.5259>;
  <D.5259>:
  D.5548 = nth_bit;
  return D.5548;
}


mono_bitset_find_last (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5553;
  unsigned int D.5554;
  unsigned int D.5555;
  long unsigned int D.5556;
  long unsigned int D.5557;
  int D.5560;
  long unsigned int D.5561;
  long unsigned int D.5566;
  unsigned int D.5567;
  unsigned int D.5568;
  unsigned int result.4;
  unsigned int D.5570;
  long unsigned int D.5571;
  int D.5574;
  unsigned int D.5575;
  long unsigned int D.5576;
  unsigned int D.5577;
  unsigned int D.5578;
  unsigned int D.5579;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5551>; else goto <D.5552>;
  <D.5551>:
  D.5553 = set->size;
  D.5554 = (unsigned int) D.5553;
  D.5555 = D.5554 + 4294967295;
  pos = (gint) D.5555;
  <D.5552>:
  D.5556 = (long unsigned int) pos;
  D.5557 = D.5556 / 64;
  j = (int) D.5557;
  bit = pos & 63;
  D.5556 = (long unsigned int) pos;
  D.5553 = set->size;
  if (D.5556 >= D.5553) goto <D.5558>; else goto <D.5559>;
  <D.5558>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 458, "pos < set->size");
  D.5560 = -1;
  return D.5560;
  <D.5559>:
  D.5561 = set->data[j];
  if (D.5561 != 0) goto <D.5562>; else goto <D.5563>;
  <D.5562>:
  D.5561 = set->data[j];
  result = my_g_bit_nth_msf (D.5561, bit);
  if (result != -1) goto <D.5564>; else goto <D.5565>;
  <D.5564>:
  D.5566 = (long unsigned int) j;
  D.5567 = (unsigned int) D.5566;
  D.5568 = D.5567 * 64;
  result.4 = (unsigned int) result;
  D.5570 = D.5568 + result.4;
  D.5560 = (int) D.5570;
  return D.5560;
  <D.5565>:
  <D.5563>:
  j = j + -1;
  i = j;
  goto <D.5310>;
  <D.5309>:
  D.5571 = set->data[i];
  if (D.5571 != 0) goto <D.5572>; else goto <D.5573>;
  <D.5572>:
  D.5571 = set->data[i];
  D.5574 = my_g_bit_nth_msf (D.5571, 64);
  D.5575 = (unsigned int) D.5574;
  D.5576 = (long unsigned int) i;
  D.5577 = (unsigned int) D.5576;
  D.5578 = D.5577 * 64;
  D.5579 = D.5575 + D.5578;
  D.5560 = (int) D.5579;
  return D.5560;
  <D.5573>:
  i = i + -1;
  <D.5310>:
  if (i >= 0) goto <D.5309>; else goto <D.5311>;
  <D.5311>:
  D.5560 = -1;
  return D.5560;
}


my_g_bit_nth_msf (gsize mask, gint nth_bit)
{
  int D.5583;
  unsigned int nth_bit.5;
  unsigned int D.5585;
  long unsigned int D.5587;
  signed long mask.6;
  unsigned int i.7;
  unsigned int nth_bit.8;
  unsigned int D.5595;
  unsigned int D.5596;
  int i;

  if (nth_bit == 0) goto <D.5581>; else goto <D.5582>;
  <D.5581>:
  D.5583 = -1;
  return D.5583;
  <D.5582>:
  nth_bit.5 = (unsigned int) nth_bit;
  D.5585 = 64 - nth_bit.5;
  mask = mask << D.5585;
  i = 64;
  goto <D.5273>;
  <D.5272>:
  mask = mask << 8;
  i = i + -8;
  <D.5273>:
  if (i > 0) goto <D.5586>; else goto <D.5274>;
  <D.5586>:
  D.5587 = mask >> 56;
  if (D.5587 == 0) goto <D.5272>; else goto <D.5274>;
  <D.5274>:
  if (mask == 0) goto <D.5588>; else goto <D.5589>;
  <D.5588>:
  D.5583 = -1;
  return D.5583;
  <D.5589>:
  <D.5275>:
  i = i + -1;
  mask.6 = (signed long) mask;
  if (mask.6 < 0) goto <D.5591>; else goto <D.5592>;
  <D.5591>:
  i.7 = (unsigned int) i;
  nth_bit.8 = (unsigned int) nth_bit;
  D.5595 = i.7 + nth_bit.8;
  D.5596 = D.5595 + 4294967232;
  D.5583 = (int) D.5596;
  return D.5583;
  <D.5592>:
  mask = mask << 1;
  if (mask != 0) goto <D.5275>; else goto <D.5276>;
  <D.5276>:
  D.5583 = -1;
  return D.5583;
}


mono_bitset_find_first_unset (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5601;
  long unsigned int D.5602;
  long unsigned int D.5603;
  int D.5606;
  long unsigned int D.5607;
  long unsigned int D.5612;
  unsigned int D.5613;
  unsigned int D.5614;
  unsigned int result.9;
  unsigned int D.5616;
  long unsigned int D.5617;
  int D.5620;
  unsigned int D.5621;
  long unsigned int D.5622;
  unsigned int D.5623;
  unsigned int D.5624;
  unsigned int D.5625;
  long unsigned int D.5626;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5598>; else goto <D.5599>;
  <D.5598>:
  j = 0;
  bit = -1;
  goto <D.5600>;
  <D.5599>:
  D.5601 = (long unsigned int) pos;
  D.5602 = D.5601 / 64;
  j = (int) D.5602;
  bit = pos & 63;
  D.5601 = (long unsigned int) pos;
  D.5603 = set->size;
  if (D.5601 >= D.5603) goto <D.5604>; else goto <D.5605>;
  <D.5604>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 492, "pos < set->size");
  D.5606 = -1;
  return D.5606;
  <D.5605>:
  <D.5600>:
  D.5607 = set->data[j];
  if (D.5607 != 18446744073709551615) goto <D.5608>; else goto <D.5609>;
  <D.5608>:
  D.5607 = set->data[j];
  result = find_first_unset (D.5607, bit);
  if (result != -1) goto <D.5610>; else goto <D.5611>;
  <D.5610>:
  D.5612 = (long unsigned int) j;
  D.5613 = (unsigned int) D.5612;
  D.5614 = D.5613 * 64;
  result.9 = (unsigned int) result;
  D.5616 = D.5614 + result.9;
  D.5606 = (int) D.5616;
  return D.5606;
  <D.5611>:
  <D.5609>:
  j = j + 1;
  i = j;
  goto <D.5321>;
  <D.5320>:
  D.5617 = set->data[i];
  if (D.5617 != 18446744073709551615) goto <D.5618>; else goto <D.5619>;
  <D.5618>:
  D.5617 = set->data[i];
  D.5620 = find_first_unset (D.5617, -1);
  D.5621 = (unsigned int) D.5620;
  D.5622 = (long unsigned int) i;
  D.5623 = (unsigned int) D.5622;
  D.5624 = D.5623 * 64;
  D.5625 = D.5621 + D.5624;
  D.5606 = (int) D.5625;
  return D.5606;
  <D.5619>:
  i = i + 1;
  <D.5321>:
  D.5622 = (long unsigned int) i;
  D.5603 = set->size;
  D.5626 = D.5603 / 64;
  if (D.5622 < D.5626) goto <D.5320>; else goto <D.5322>;
  <D.5322>:
  D.5606 = -1;
  return D.5606;
}


find_first_unset (gsize mask, gint nth_bit)
{
  long unsigned int D.5628;
  long unsigned int D.5629;
  int D.5634;
  unsigned int nth_bit.10;

  <D.5281>:
  nth_bit = nth_bit + 1;
  D.5628 = mask >> nth_bit;
  D.5629 = D.5628 & 1;
  if (D.5629 == 0) goto <D.5630>; else goto <D.5631>;
  <D.5630>:
  if (nth_bit == 64) goto <D.5632>; else goto <D.5633>;
  <D.5632>:
  D.5634 = -1;
  return D.5634;
  <D.5633>:
  D.5634 = nth_bit;
  return D.5634;
  <D.5631>:
  nth_bit.10 = (unsigned int) nth_bit;
  if (nth_bit.10 <= 63) goto <D.5281>; else goto <D.5282>;
  <D.5282>:
  D.5634 = -1;
  return D.5634;
}


mono_bitset_clone (const struct MonoBitSet * set, guint32 new_size)
{
  long unsigned int D.5639;
  long unsigned int D.5640;
  unsigned int D.5641;
  long unsigned int D.5642;
  long unsigned int D.5643;
  gsize[0:] * D.5644;
  const gsize[0:] * D.5645;
  long unsigned int D.5646;
  struct MonoBitSet * D.5647;
  struct MonoBitSet * result;

  if (new_size == 0) goto <D.5637>; else goto <D.5638>;
  <D.5637>:
  D.5639 = set->size;
  new_size = (guint32) D.5639;
  <D.5638>:
  D.5640 = set->flags;
  D.5641 = (unsigned int) D.5640;
  result = mono_bitset_new (new_size, D.5641);
  D.5642 = result->flags;
  D.5643 = D.5642 & 18446744073709551614;
  result->flags = D.5643;
  D.5644 = &result->data;
  D.5645 = &set->data;
  D.5639 = set->size;
  D.5646 = D.5639 / 8;
  memcpy (D.5644, D.5645, D.5646);
  D.5647 = result;
  return D.5647;
}


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

  D.5650 = __builtin_object_size (__dest, 0);
  D.5649 = __builtin___memcpy_chk (__dest, __src, __len, D.5650);
  return D.5649;
}


mono_bitset_copyto (const struct MonoBitSet * src, struct MonoBitSet * dest)
{
  long unsigned int D.5652;
  long unsigned int D.5653;
  _Bool D.5654;
  long int D.5655;
  long int D.5656;
  gsize[0:] * D.5659;
  const gsize[0:] * D.5660;
  long unsigned int D.5661;

  D.5652 = dest->size;
  D.5653 = src->size;
  D.5654 = D.5652 > D.5653;
  D.5655 = (long int) D.5654;
  D.5656 = __builtin_expect (D.5655, 0);
  if (D.5656 != 0) goto <D.5657>; else goto <D.5658>;
  <D.5657>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 539, "dest->size <= src->size");
  <D.5658>:
  D.5659 = &dest->data;
  D.5660 = &src->data;
  D.5652 = dest->size;
  D.5661 = D.5652 / 8;
  memcpy (D.5659, D.5660, D.5661);
}


mono_bitset_union (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5662;
  long unsigned int D.5663;
  _Bool D.5664;
  long int D.5665;
  long int D.5666;
  long unsigned int D.5669;
  long unsigned int D.5670;
  long unsigned int D.5671;
  long unsigned int D.5672;
  int i;
  int size;

  D.5662 = src->size;
  D.5663 = dest->size;
  D.5664 = D.5662 > D.5663;
  D.5665 = (long int) D.5664;
  D.5666 = __builtin_expect (D.5665, 0);
  if (D.5666 != 0) goto <D.5667>; else goto <D.5668>;
  <D.5667>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 555, "src->size <= dest->size");
  <D.5668>:
  D.5663 = dest->size;
  D.5669 = D.5663 / 64;
  size = (int) D.5669;
  i = 0;
  goto <D.5339>;
  <D.5338>:
  D.5670 = dest->data[i];
  D.5671 = src->data[i];
  D.5672 = D.5670 | D.5671;
  dest->data[i] = D.5672;
  i = i + 1;
  <D.5339>:
  if (i < size) goto <D.5338>; else goto <D.5340>;
  <D.5340>:
}


mono_bitset_intersection (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5673;
  long unsigned int D.5674;
  _Bool D.5675;
  long int D.5676;
  long int D.5677;
  long unsigned int D.5680;
  long unsigned int D.5681;
  long unsigned int D.5682;
  long unsigned int D.5683;
  int i;
  int size;

  D.5673 = src->size;
  D.5674 = dest->size;
  D.5675 = D.5673 > D.5674;
  D.5676 = (long int) D.5675;
  D.5677 = __builtin_expect (D.5676, 0);
  if (D.5677 != 0) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 573, "src->size <= dest->size");
  <D.5679>:
  D.5674 = dest->size;
  D.5680 = D.5674 / 64;
  size = (int) D.5680;
  i = 0;
  goto <D.5348>;
  <D.5347>:
  D.5681 = dest->data[i];
  D.5682 = src->data[i];
  D.5683 = D.5681 & D.5682;
  dest->data[i] = D.5683;
  i = i + 1;
  <D.5348>:
  if (i < size) goto <D.5347>; else goto <D.5349>;
  <D.5349>:
}


mono_bitset_intersection_2 (struct MonoBitSet * dest, const struct MonoBitSet * src1, const struct MonoBitSet * src2)
{
  long unsigned int D.5684;
  long unsigned int D.5685;
  _Bool D.5686;
  long int D.5687;
  long int D.5688;
  long unsigned int D.5691;
  _Bool D.5692;
  long int D.5693;
  long int D.5694;
  long unsigned int D.5697;
  long unsigned int D.5698;
  long unsigned int D.5699;
  long unsigned int D.5700;
  int i;
  int size;

  D.5684 = src1->size;
  D.5685 = dest->size;
  D.5686 = D.5684 > D.5685;
  D.5687 = (long int) D.5686;
  D.5688 = __builtin_expect (D.5687, 0);
  if (D.5688 != 0) goto <D.5689>; else goto <D.5690>;
  <D.5689>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 592, "src1->size <= dest->size");
  <D.5690>:
  D.5691 = src2->size;
  D.5685 = dest->size;
  D.5692 = D.5691 > D.5685;
  D.5693 = (long int) D.5692;
  D.5694 = __builtin_expect (D.5693, 0);
  if (D.5694 != 0) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 593, "src2->size <= dest->size");
  <D.5696>:
  D.5685 = dest->size;
  D.5697 = D.5685 / 64;
  size = (int) D.5697;
  i = 0;
  goto <D.5358>;
  <D.5357>:
  D.5698 = src1->data[i];
  D.5699 = src2->data[i];
  D.5700 = D.5698 & D.5699;
  dest->data[i] = D.5700;
  i = i + 1;
  <D.5358>:
  if (i < size) goto <D.5357>; else goto <D.5359>;
  <D.5359>:
}


mono_bitset_sub (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5701;
  long unsigned int D.5702;
  _Bool D.5703;
  long int D.5704;
  long int D.5705;
  long unsigned int D.5708;
  long unsigned int D.5709;
  long unsigned int D.5710;
  long unsigned int D.5711;
  long unsigned int D.5712;
  int i;
  int size;

  D.5701 = src->size;
  D.5702 = dest->size;
  D.5703 = D.5701 > D.5702;
  D.5704 = (long int) D.5703;
  D.5705 = __builtin_expect (D.5704, 0);
  if (D.5705 != 0) goto <D.5706>; else goto <D.5707>;
  <D.5706>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 611, "src->size <= dest->size");
  <D.5707>:
  D.5701 = src->size;
  D.5708 = D.5701 / 64;
  size = (int) D.5708;
  i = 0;
  goto <D.5367>;
  <D.5366>:
  D.5709 = dest->data[i];
  D.5710 = src->data[i];
  D.5711 = ~D.5710;
  D.5712 = D.5709 & D.5711;
  dest->data[i] = D.5712;
  i = i + 1;
  <D.5367>:
  if (i < size) goto <D.5366>; else goto <D.5368>;
  <D.5368>:
}


mono_bitset_equal (const struct MonoBitSet * src, const struct MonoBitSet * src1)
{
  long unsigned int D.5713;
  long unsigned int D.5714;
  gboolean D.5717;
  long unsigned int D.5718;
  long unsigned int D.5719;
  long unsigned int D.5722;
  long unsigned int D.5723;
  int i;

  D.5713 = src->size;
  D.5714 = src1->size;
  if (D.5713 != D.5714) goto <D.5715>; else goto <D.5716>;
  <D.5715>:
  D.5717 = 0;
  return D.5717;
  <D.5716>:
  i = 0;
  goto <D.5375>;
  <D.5374>:
  D.5718 = src->data[i];
  D.5719 = src1->data[i];
  if (D.5718 != D.5719) goto <D.5720>; else goto <D.5721>;
  <D.5720>:
  D.5717 = 0;
  return D.5717;
  <D.5721>:
  i = i + 1;
  <D.5375>:
  D.5722 = (long unsigned int) i;
  D.5713 = src->size;
  D.5723 = D.5713 / 64;
  if (D.5722 < D.5723) goto <D.5374>; else goto <D.5376>;
  <D.5376>:
  D.5717 = 1;
  return D.5717;
}


mono_bitset_foreach (struct MonoBitSet * set, void (*MonoBitSetFunc) (guint, void *) func, void * data)
{
  long unsigned int D.5725;
  long unsigned int D.5728;
  long unsigned int D.5729;
  long unsigned int D.5732;
  unsigned int D.5733;
  unsigned int D.5734;
  unsigned int j.11;
  unsigned int D.5736;
  unsigned int j.12;
  long unsigned int D.5738;
  long unsigned int D.5739;
  int i;
  int j;

  i = 0;
  goto <D.5388>;
  <D.5387>:
  D.5725 = set->data[i];
  if (D.5725 != 0) goto <D.5726>; else goto <D.5727>;
  <D.5726>:
  j = 0;
  goto <D.5385>;
  <D.5384>:
  D.5725 = set->data[i];
  D.5728 = D.5725 >> j;
  D.5729 = D.5728 & 1;
  if (D.5729 != 0) goto <D.5730>; else goto <D.5731>;
  <D.5730>:
  D.5732 = (long unsigned int) i;
  D.5733 = (unsigned int) D.5732;
  D.5734 = D.5733 * 64;
  j.11 = (unsigned int) j;
  D.5736 = D.5734 + j.11;
  func (D.5736, data);
  <D.5731>:
  j = j + 1;
  <D.5385>:
  j.12 = (unsigned int) j;
  if (j.12 <= 63) goto <D.5384>; else goto <D.5386>;
  <D.5386>:
  <D.5727>:
  i = i + 1;
  <D.5388>:
  D.5732 = (long unsigned int) i;
  D.5738 = set->size;
  D.5739 = D.5738 / 64;
  if (D.5732 < D.5739) goto <D.5387>; else goto <D.5389>;
  <D.5389>:
}