mono_bitset_alloc_size (guint32 max_size, guint32 flags)
{
  unsigned int D.7483;
  guint32 D.7484;
  unsigned int D.7485;
  guint32 real_size;

  D.7483 = max_size + 31;
  real_size = D.7483 / 32;
  D.7485 = real_size + 2;
  D.7484 = D.7485 * 4;
  return D.7484;
}


mono_bitset_new (guint32 max_size, guint32 flags)
{
  unsigned int D.7487;
  unsigned int D.7488;
  unsigned int D.7489;
  unsigned int D.7490;
  struct MonoBitSet * D.7491;
  guint32 real_size;
  struct MonoBitSet * result;

  D.7487 = max_size + 31;
  real_size = D.7487 / 32;
  D.7488 = real_size + 2;
  D.7489 = D.7488 * 4;
  result = monoeg_malloc0 (D.7489);
  D.7490 = real_size * 32;
  result->size = D.7490;
  result->flags = flags;
  D.7491 = result;
  return D.7491;
}


mono_bitset_mem_new (void * mem, guint32 max_size, guint32 flags)
{
  unsigned int D.7493;
  unsigned int D.7494;
  unsigned int D.7495;
  struct MonoBitSet * D.7496;
  guint32 real_size;
  struct MonoBitSet * result;

  D.7493 = max_size + 31;
  real_size = D.7493 / 32;
  result = mem;
  D.7494 = real_size * 32;
  result->size = D.7494;
  D.7495 = flags | 1;
  result->flags = D.7495;
  D.7496 = result;
  return D.7496;
}


mono_bitset_free (struct MonoBitSet * set)
{
  unsigned int D.7498;
  unsigned int D.7499;

  D.7498 = set->flags;
  D.7499 = D.7498 & 1;
  if (D.7499 == 0) goto <D.7500>; else goto <D.7501>;
  <D.7500>:
  monoeg_g_free (set);
  <D.7501>:
}


mono_bitset_set (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.7502;
  int pos.0;
  unsigned int D.7504;
  _Bool D.7505;
  long int D.7506;
  long int D.7507;
  unsigned int D.7510;
  unsigned int D.7511;
  unsigned int D.7512;
  int j;
  int bit;

  D.7502 = pos / 32;
  j = (int) D.7502;
  pos.0 = (int) pos;
  bit = pos.0 & 31;
  D.7504 = set->size;
  D.7505 = D.7504 <= pos;
  D.7506 = (long int) D.7505;
  D.7507 = __builtin_expect (D.7506, 0);
  if (D.7507 != 0) goto <D.7508>; else goto <D.7509>;
  <D.7508>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 90, "pos < set->size");
  <D.7509>:
  D.7510 = set->data[j];
  D.7511 = 1 << bit;
  D.7512 = D.7510 | D.7511;
  set->data[j] = D.7512;
}


mono_bitset_test (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.7513;
  int pos.1;
  unsigned int D.7515;
  int D.7518;
  unsigned int D.7519;
  unsigned int D.7520;
  unsigned int D.7521;
  _Bool D.7522;
  int j;
  int bit;

  D.7513 = pos / 32;
  j = (int) D.7513;
  pos.1 = (int) pos;
  bit = pos.1 & 31;
  D.7515 = set->size;
  if (D.7515 <= pos) goto <D.7516>; else goto <D.7517>;
  <D.7516>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 108, "pos < set->size");
  D.7518 = 0;
  return D.7518;
  <D.7517>:
  D.7519 = set->data[j];
  D.7520 = D.7519 >> bit;
  D.7521 = D.7520 & 1;
  D.7522 = D.7521 != 0;
  D.7518 = (int) D.7522;
  return D.7518;
}


mono_bitset_test_bulk (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.7524;
  unsigned int D.7525;
  gsize D.7528;
  int j;

  D.7524 = pos / 32;
  j = (int) D.7524;
  D.7525 = set->size;
  if (D.7525 <= pos) goto <D.7526>; else goto <D.7527>;
  <D.7526>:
  D.7528 = 0;
  return D.7528;
  <D.7527>:
  D.7528 = set->data[j];
  return D.7528;
}


mono_bitset_clear (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.7530;
  int pos.2;
  unsigned int D.7532;
  _Bool D.7533;
  long int D.7534;
  long int D.7535;
  unsigned int D.7538;
  unsigned int D.7539;
  unsigned int D.7540;
  unsigned int D.7541;
  int j;
  int bit;

  D.7530 = pos / 32;
  j = (int) D.7530;
  pos.2 = (int) pos;
  bit = pos.2 & 31;
  D.7532 = set->size;
  D.7533 = D.7532 <= pos;
  D.7534 = (long int) D.7533;
  D.7535 = __builtin_expect (D.7534, 0);
  if (D.7535 != 0) goto <D.7536>; else goto <D.7537>;
  <D.7536>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 143, "pos < set->size");
  <D.7537>:
  D.7538 = set->data[j];
  D.7539 = 1 << bit;
  D.7540 = ~D.7539;
  D.7541 = D.7538 & D.7540;
  set->data[j] = D.7541;
}


mono_bitset_clear_all (struct MonoBitSet * set)
{
  gsize[0:] * D.7542;
  unsigned int D.7543;
  unsigned int D.7544;

  D.7542 = &set->data;
  D.7543 = set->size;
  D.7544 = D.7543 / 8;
  memset (D.7542, 0, D.7544);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7547;
  int D.7552;
  void * D.7554;
  unsigned int D.7555;

  D.7547 = __builtin_constant_p (__len);
  if (D.7547 != 0) goto <D.7548>; else goto <D.7549>;
  <D.7548>:
  if (__len == 0) goto <D.7550>; else goto <D.7551>;
  <D.7550>:
  D.7552 = __builtin_constant_p (__ch);
  if (D.7552 == 0) goto <D.7545>; else goto <D.7553>;
  <D.7553>:
  if (__ch != 0) goto <D.7545>; else goto <D.7546>;
  <D.7545>:
  __warn_memset_zero_len ();
  D.7554 = __dest;
  return D.7554;
  <D.7546>:
  <D.7551>:
  <D.7549>:
  D.7555 = __builtin_object_size (__dest, 0);
  D.7554 = __builtin___memset_chk (__dest, __ch, __len, D.7555);
  return D.7554;
}


mono_bitset_set_all (struct MonoBitSet * set)
{
  gsize[0:] * D.7557;
  unsigned int D.7558;
  unsigned int D.7559;

  D.7557 = &set->data;
  D.7558 = set->size;
  D.7559 = D.7558 / 8;
  memset (D.7557, -1, D.7559);
}


mono_bitset_invert (struct MonoBitSet * set)
{
  unsigned int D.7560;
  unsigned int D.7561;
  unsigned int i.3;
  unsigned int D.7563;
  unsigned int D.7564;
  int i;

  i = 0;
  goto <D.7329>;
  <D.7328>:
  D.7560 = set->data[i];
  D.7561 = ~D.7560;
  set->data[i] = D.7561;
  i = i + 1;
  <D.7329>:
  i.3 = (unsigned int) i;
  D.7563 = set->size;
  D.7564 = D.7563 / 32;
  if (i.3 < D.7564) goto <D.7328>; else goto <D.7330>;
  <D.7330>:
}


mono_bitset_size (const struct MonoBitSet * set)
{
  guint32 D.7565;

  D.7565 = set->size;
  return D.7565;
}


mono_bitset_count (const struct MonoBitSet * set)
{
  int D.7569;
  unsigned int D.7570;
  int D.7572;
  unsigned int D.7573;
  unsigned int D.7574;
  unsigned int D.7575;
  guint32 D.7576;
  guint32 i;
  guint32 count;
  gsize d;

  count = 0;
  i = 0;
  goto <D.7341>;
  <D.7340>:
  d = set->data[i];
  if (1 != 0) goto <D.7567>; else goto <D.7568>;
  <D.7567>:
  D.7569 = __builtin_popcountl (d);
  D.7570 = (unsigned int) D.7569;
  count = D.7570 + count;
  goto <D.7571>;
  <D.7568>:
  D.7572 = __builtin_popcount (d);
  D.7573 = (unsigned int) D.7572;
  count = D.7573 + count;
  <D.7571>:
  i = i + 1;
  <D.7341>:
  D.7574 = set->size;
  D.7575 = D.7574 / 32;
  if (D.7575 > i) goto <D.7340>; else goto <D.7342>;
  <D.7342>:
  D.7576 = count;
  return D.7576;
}


mono_bitset_find_start (const struct MonoBitSet * set)
{
  unsigned int D.7578;
  int D.7581;
  int D.7582;
  unsigned int D.7583;
  unsigned int i.4;
  unsigned int D.7585;
  unsigned int D.7586;
  unsigned int D.7587;
  unsigned int D.7588;
  int i;

  i = 0;
  goto <D.7378>;
  <D.7377>:
  D.7578 = set->data[i];
  if (D.7578 != 0) goto <D.7579>; else goto <D.7580>;
  <D.7579>:
  D.7578 = set->data[i];
  D.7582 = my_g_bit_nth_lsf_nomask (D.7578);
  D.7583 = (unsigned int) D.7582;
  i.4 = (unsigned int) i;
  D.7585 = i.4 * 32;
  D.7586 = D.7583 + D.7585;
  D.7581 = (int) D.7586;
  return D.7581;
  <D.7580>:
  i = i + 1;
  <D.7378>:
  i.4 = (unsigned int) i;
  D.7587 = set->size;
  D.7588 = D.7587 / 32;
  if (i.4 < D.7588) goto <D.7377>; else goto <D.7379>;
  <D.7379>:
  D.7581 = -1;
  return D.7581;
}


my_g_bit_nth_lsf_nomask (gsize mask)
{
  unsigned int D.7590;
  gint D.7591;
  int nth_bit;

  nth_bit = 0;
  goto <D.7355>;
  <D.7354>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.7355>:
  D.7590 = mask & 1;
  if (D.7590 == 0) goto <D.7354>; else goto <D.7356>;
  <D.7356>:
  D.7591 = nth_bit;
  return D.7591;
}


mono_bitset_find_first (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.5;
  unsigned int D.7597;
  unsigned int D.7598;
  _Bool D.7599;
  long int D.7600;
  long int D.7601;
  unsigned int D.7604;
  int D.7609;
  unsigned int j.6;
  unsigned int D.7611;
  unsigned int result.7;
  unsigned int D.7613;
  unsigned int D.7614;
  int D.7617;
  unsigned int D.7618;
  unsigned int i.8;
  unsigned int D.7620;
  unsigned int D.7621;
  unsigned int D.7622;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.7593>; else goto <D.7594>;
  <D.7593>:
  j = 0;
  bit = -1;
  goto <D.7595>;
  <D.7594>:
  pos.5 = (unsigned int) pos;
  D.7597 = pos.5 / 32;
  j = (int) D.7597;
  bit = pos & 31;
  pos.5 = (unsigned int) pos;
  D.7598 = set->size;
  D.7599 = pos.5 >= D.7598;
  D.7600 = (long int) D.7599;
  D.7601 = __builtin_expect (D.7600, 0);
  if (D.7601 != 0) goto <D.7602>; else goto <D.7603>;
  <D.7602>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 424, "pos < set->size");
  <D.7603>:
  <D.7595>:
  D.7604 = set->data[j];
  if (D.7604 != 0) goto <D.7605>; else goto <D.7606>;
  <D.7605>:
  D.7604 = set->data[j];
  result = my_g_bit_nth_lsf (D.7604, bit);
  if (result != -1) goto <D.7607>; else goto <D.7608>;
  <D.7607>:
  j.6 = (unsigned int) j;
  D.7611 = j.6 * 32;
  result.7 = (unsigned int) result;
  D.7613 = D.7611 + result.7;
  D.7609 = (int) D.7613;
  return D.7609;
  <D.7608>:
  <D.7606>:
  j = j + 1;
  i = j;
  goto <D.7389>;
  <D.7388>:
  D.7614 = set->data[i];
  if (D.7614 != 0) goto <D.7615>; else goto <D.7616>;
  <D.7615>:
  D.7614 = set->data[i];
  D.7617 = my_g_bit_nth_lsf (D.7614, -1);
  D.7618 = (unsigned int) D.7617;
  i.8 = (unsigned int) i;
  D.7620 = i.8 * 32;
  D.7621 = D.7618 + D.7620;
  D.7609 = (int) D.7621;
  return D.7609;
  <D.7616>:
  i = i + 1;
  <D.7389>:
  i.8 = (unsigned int) i;
  D.7598 = set->size;
  D.7622 = D.7598 / 32;
  if (i.8 < D.7622) goto <D.7388>; else goto <D.7390>;
  <D.7390>:
  D.7609 = -1;
  return D.7609;
}


my_g_bit_nth_lsf (gsize mask, gint nth_bit)
{
  _Bool D.7624;
  _Bool D.7625;
  _Bool D.7626;
  gint D.7629;
  unsigned int D.7630;

  nth_bit = nth_bit + 1;
  mask = mask >> nth_bit;
  D.7624 = mask == 0;
  D.7625 = nth_bit == 32;
  D.7626 = D.7624 | D.7625;
  if (D.7626 != 0) goto <D.7627>; else goto <D.7628>;
  <D.7627>:
  D.7629 = -1;
  return D.7629;
  <D.7628>:
  goto <D.7348>;
  <D.7347>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.7348>:
  D.7630 = mask & 1;
  if (D.7630 == 0) goto <D.7347>; else goto <D.7349>;
  <D.7349>:
  D.7629 = nth_bit;
  return D.7629;
}


mono_bitset_find_last (const struct MonoBitSet * set, gint pos)
{
  unsigned int D.7634;
  unsigned int D.7635;
  unsigned int pos.9;
  unsigned int D.7637;
  int D.7640;
  unsigned int D.7641;
  unsigned int j.10;
  unsigned int D.7647;
  unsigned int result.11;
  unsigned int D.7649;
  unsigned int D.7650;
  int D.7653;
  unsigned int D.7654;
  unsigned int i.12;
  unsigned int D.7656;
  unsigned int D.7657;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.7632>; else goto <D.7633>;
  <D.7632>:
  D.7634 = set->size;
  D.7635 = D.7634 + 4294967295;
  pos = (gint) D.7635;
  <D.7633>:
  pos.9 = (unsigned int) pos;
  D.7637 = pos.9 / 32;
  j = (int) D.7637;
  bit = pos & 31;
  pos.9 = (unsigned int) pos;
  D.7634 = set->size;
  if (pos.9 >= D.7634) goto <D.7638>; else goto <D.7639>;
  <D.7638>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 458, "pos < set->size");
  D.7640 = -1;
  return D.7640;
  <D.7639>:
  D.7641 = set->data[j];
  if (D.7641 != 0) goto <D.7642>; else goto <D.7643>;
  <D.7642>:
  D.7641 = set->data[j];
  result = my_g_bit_nth_msf (D.7641, bit);
  if (result != -1) goto <D.7644>; else goto <D.7645>;
  <D.7644>:
  j.10 = (unsigned int) j;
  D.7647 = j.10 * 32;
  result.11 = (unsigned int) result;
  D.7649 = D.7647 + result.11;
  D.7640 = (int) D.7649;
  return D.7640;
  <D.7645>:
  <D.7643>:
  j = j + -1;
  i = j;
  goto <D.7400>;
  <D.7399>:
  D.7650 = set->data[i];
  if (D.7650 != 0) goto <D.7651>; else goto <D.7652>;
  <D.7651>:
  D.7650 = set->data[i];
  D.7653 = my_g_bit_nth_msf (D.7650, 32);
  D.7654 = (unsigned int) D.7653;
  i.12 = (unsigned int) i;
  D.7656 = i.12 * 32;
  D.7657 = D.7654 + D.7656;
  D.7640 = (int) D.7657;
  return D.7640;
  <D.7652>:
  i = i + -1;
  <D.7400>:
  if (i >= 0) goto <D.7399>; else goto <D.7401>;
  <D.7401>:
  D.7640 = -1;
  return D.7640;
}


my_g_bit_nth_msf (gsize mask, gint nth_bit)
{
  int D.7661;
  unsigned int nth_bit.13;
  unsigned int D.7663;
  int D.7664;
  unsigned int D.7666;
  signed int mask.14;
  unsigned int i.15;
  unsigned int D.7673;
  unsigned int D.7674;
  int i;

  if (nth_bit == 0) goto <D.7659>; else goto <D.7660>;
  <D.7659>:
  D.7661 = -1;
  return D.7661;
  <D.7660>:
  nth_bit.13 = (unsigned int) nth_bit;
  D.7663 = 32 - nth_bit.13;
  D.7664 = (int) D.7663;
  mask = mask << D.7664;
  i = 32;
  goto <D.7363>;
  <D.7362>:
  mask = mask << 8;
  i = i + -8;
  <D.7363>:
  if (i > 0) goto <D.7665>; else goto <D.7364>;
  <D.7665>:
  D.7666 = mask >> 24;
  if (D.7666 == 0) goto <D.7362>; else goto <D.7364>;
  <D.7364>:
  if (mask == 0) goto <D.7667>; else goto <D.7668>;
  <D.7667>:
  D.7661 = -1;
  return D.7661;
  <D.7668>:
  <D.7365>:
  i = i + -1;
  mask.14 = (signed int) mask;
  if (mask.14 < 0) goto <D.7670>; else goto <D.7671>;
  <D.7670>:
  nth_bit.13 = (unsigned int) nth_bit;
  i.15 = (unsigned int) i;
  D.7673 = nth_bit.13 + i.15;
  D.7674 = D.7673 + 4294967264;
  D.7661 = (int) D.7674;
  return D.7661;
  <D.7671>:
  mask = mask << 1;
  if (mask != 0) goto <D.7365>; else goto <D.7366>;
  <D.7366>:
  D.7661 = -1;
  return D.7661;
}


mono_bitset_find_first_unset (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.16;
  unsigned int D.7680;
  unsigned int D.7681;
  int D.7684;
  unsigned int D.7685;
  unsigned int j.17;
  unsigned int D.7691;
  unsigned int result.18;
  unsigned int D.7693;
  unsigned int D.7694;
  int D.7697;
  unsigned int D.7698;
  unsigned int i.19;
  unsigned int D.7700;
  unsigned int D.7701;
  unsigned int D.7702;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.7676>; else goto <D.7677>;
  <D.7676>:
  j = 0;
  bit = -1;
  goto <D.7678>;
  <D.7677>:
  pos.16 = (unsigned int) pos;
  D.7680 = pos.16 / 32;
  j = (int) D.7680;
  bit = pos & 31;
  pos.16 = (unsigned int) pos;
  D.7681 = set->size;
  if (pos.16 >= D.7681) goto <D.7682>; else goto <D.7683>;
  <D.7682>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 492, "pos < set->size");
  D.7684 = -1;
  return D.7684;
  <D.7683>:
  <D.7678>:
  D.7685 = set->data[j];
  if (D.7685 != 4294967295) goto <D.7686>; else goto <D.7687>;
  <D.7686>:
  D.7685 = set->data[j];
  result = find_first_unset (D.7685, bit);
  if (result != -1) goto <D.7688>; else goto <D.7689>;
  <D.7688>:
  j.17 = (unsigned int) j;
  D.7691 = j.17 * 32;
  result.18 = (unsigned int) result;
  D.7693 = D.7691 + result.18;
  D.7684 = (int) D.7693;
  return D.7684;
  <D.7689>:
  <D.7687>:
  j = j + 1;
  i = j;
  goto <D.7411>;
  <D.7410>:
  D.7694 = set->data[i];
  if (D.7694 != 4294967295) goto <D.7695>; else goto <D.7696>;
  <D.7695>:
  D.7694 = set->data[i];
  D.7697 = find_first_unset (D.7694, -1);
  D.7698 = (unsigned int) D.7697;
  i.19 = (unsigned int) i;
  D.7700 = i.19 * 32;
  D.7701 = D.7698 + D.7700;
  D.7684 = (int) D.7701;
  return D.7684;
  <D.7696>:
  i = i + 1;
  <D.7411>:
  i.19 = (unsigned int) i;
  D.7681 = set->size;
  D.7702 = D.7681 / 32;
  if (i.19 < D.7702) goto <D.7410>; else goto <D.7412>;
  <D.7412>:
  D.7684 = -1;
  return D.7684;
}


find_first_unset (gsize mask, gint nth_bit)
{
  unsigned int D.7704;
  unsigned int D.7705;
  int D.7710;
  unsigned int nth_bit.20;

  <D.7371>:
  nth_bit = nth_bit + 1;
  D.7704 = 1 << nth_bit;
  D.7705 = D.7704 & mask;
  if (D.7705 == 0) goto <D.7706>; else goto <D.7707>;
  <D.7706>:
  if (nth_bit == 32) goto <D.7708>; else goto <D.7709>;
  <D.7708>:
  D.7710 = -1;
  return D.7710;
  <D.7709>:
  D.7710 = nth_bit;
  return D.7710;
  <D.7707>:
  nth_bit.20 = (unsigned int) nth_bit;
  if (nth_bit.20 <= 31) goto <D.7371>; else goto <D.7372>;
  <D.7372>:
  D.7710 = -1;
  return D.7710;
}


mono_bitset_clone (const struct MonoBitSet * set, guint32 new_size)
{
  unsigned int D.7715;
  unsigned int D.7716;
  unsigned int D.7717;
  gsize[0:] * D.7718;
  const gsize[0:] * D.7719;
  unsigned int D.7720;
  unsigned int D.7721;
  struct MonoBitSet * D.7722;
  struct MonoBitSet * result;

  if (new_size == 0) goto <D.7713>; else goto <D.7714>;
  <D.7713>:
  new_size = set->size;
  <D.7714>:
  D.7715 = set->flags;
  result = mono_bitset_new (new_size, D.7715);
  D.7716 = result->flags;
  D.7717 = D.7716 & 4294967294;
  result->flags = D.7717;
  D.7718 = &result->data;
  D.7719 = &set->data;
  D.7720 = set->size;
  D.7721 = D.7720 / 8;
  memcpy (D.7718, D.7719, D.7721);
  D.7722 = result;
  return D.7722;
}


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

  D.7725 = __builtin_object_size (__dest, 0);
  D.7724 = __builtin___memcpy_chk (__dest, __src, __len, D.7725);
  return D.7724;
}


mono_bitset_copyto (const struct MonoBitSet * src, struct MonoBitSet * dest)
{
  unsigned int D.7727;
  unsigned int D.7728;
  _Bool D.7729;
  long int D.7730;
  long int D.7731;
  gsize[0:] * D.7734;
  const gsize[0:] * D.7735;
  unsigned int D.7736;

  D.7727 = dest->size;
  D.7728 = src->size;
  D.7729 = D.7727 > D.7728;
  D.7730 = (long int) D.7729;
  D.7731 = __builtin_expect (D.7730, 0);
  if (D.7731 != 0) goto <D.7732>; else goto <D.7733>;
  <D.7732>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 539, "dest->size <= src->size");
  <D.7733>:
  D.7734 = &dest->data;
  D.7735 = &src->data;
  D.7727 = dest->size;
  D.7736 = D.7727 / 8;
  memcpy (D.7734, D.7735, D.7736);
}


mono_bitset_union (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.7737;
  unsigned int D.7738;
  _Bool D.7739;
  long int D.7740;
  long int D.7741;
  unsigned int D.7744;
  unsigned int D.7745;
  unsigned int D.7746;
  unsigned int D.7747;
  int i;
  int size;

  D.7737 = src->size;
  D.7738 = dest->size;
  D.7739 = D.7737 > D.7738;
  D.7740 = (long int) D.7739;
  D.7741 = __builtin_expect (D.7740, 0);
  if (D.7741 != 0) goto <D.7742>; else goto <D.7743>;
  <D.7742>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 555, "src->size <= dest->size");
  <D.7743>:
  D.7738 = dest->size;
  D.7744 = D.7738 / 32;
  size = (int) D.7744;
  i = 0;
  goto <D.7429>;
  <D.7428>:
  D.7745 = dest->data[i];
  D.7746 = src->data[i];
  D.7747 = D.7745 | D.7746;
  dest->data[i] = D.7747;
  i = i + 1;
  <D.7429>:
  if (i < size) goto <D.7428>; else goto <D.7430>;
  <D.7430>:
}


mono_bitset_intersection (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.7748;
  unsigned int D.7749;
  _Bool D.7750;
  long int D.7751;
  long int D.7752;
  unsigned int D.7755;
  unsigned int D.7756;
  unsigned int D.7757;
  unsigned int D.7758;
  int i;
  int size;

  D.7748 = src->size;
  D.7749 = dest->size;
  D.7750 = D.7748 > D.7749;
  D.7751 = (long int) D.7750;
  D.7752 = __builtin_expect (D.7751, 0);
  if (D.7752 != 0) goto <D.7753>; else goto <D.7754>;
  <D.7753>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 573, "src->size <= dest->size");
  <D.7754>:
  D.7749 = dest->size;
  D.7755 = D.7749 / 32;
  size = (int) D.7755;
  i = 0;
  goto <D.7438>;
  <D.7437>:
  D.7756 = dest->data[i];
  D.7757 = src->data[i];
  D.7758 = D.7756 & D.7757;
  dest->data[i] = D.7758;
  i = i + 1;
  <D.7438>:
  if (i < size) goto <D.7437>; else goto <D.7439>;
  <D.7439>:
}


mono_bitset_intersection_2 (struct MonoBitSet * dest, const struct MonoBitSet * src1, const struct MonoBitSet * src2)
{
  unsigned int D.7759;
  unsigned int D.7760;
  _Bool D.7761;
  long int D.7762;
  long int D.7763;
  unsigned int D.7766;
  _Bool D.7767;
  long int D.7768;
  long int D.7769;
  unsigned int D.7772;
  unsigned int D.7773;
  unsigned int D.7774;
  unsigned int D.7775;
  int i;
  int size;

  D.7759 = src1->size;
  D.7760 = dest->size;
  D.7761 = D.7759 > D.7760;
  D.7762 = (long int) D.7761;
  D.7763 = __builtin_expect (D.7762, 0);
  if (D.7763 != 0) goto <D.7764>; else goto <D.7765>;
  <D.7764>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 592, "src1->size <= dest->size");
  <D.7765>:
  D.7766 = src2->size;
  D.7760 = dest->size;
  D.7767 = D.7766 > D.7760;
  D.7768 = (long int) D.7767;
  D.7769 = __builtin_expect (D.7768, 0);
  if (D.7769 != 0) goto <D.7770>; else goto <D.7771>;
  <D.7770>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 593, "src2->size <= dest->size");
  <D.7771>:
  D.7760 = dest->size;
  D.7772 = D.7760 / 32;
  size = (int) D.7772;
  i = 0;
  goto <D.7448>;
  <D.7447>:
  D.7773 = src1->data[i];
  D.7774 = src2->data[i];
  D.7775 = D.7773 & D.7774;
  dest->data[i] = D.7775;
  i = i + 1;
  <D.7448>:
  if (i < size) goto <D.7447>; else goto <D.7449>;
  <D.7449>:
}


mono_bitset_sub (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.7776;
  unsigned int D.7777;
  _Bool D.7778;
  long int D.7779;
  long int D.7780;
  unsigned int D.7783;
  unsigned int D.7784;
  unsigned int D.7785;
  unsigned int D.7786;
  unsigned int D.7787;
  int i;
  int size;

  D.7776 = src->size;
  D.7777 = dest->size;
  D.7778 = D.7776 > D.7777;
  D.7779 = (long int) D.7778;
  D.7780 = __builtin_expect (D.7779, 0);
  if (D.7780 != 0) goto <D.7781>; else goto <D.7782>;
  <D.7781>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 611, "src->size <= dest->size");
  <D.7782>:
  D.7776 = src->size;
  D.7783 = D.7776 / 32;
  size = (int) D.7783;
  i = 0;
  goto <D.7457>;
  <D.7456>:
  D.7784 = dest->data[i];
  D.7785 = src->data[i];
  D.7786 = ~D.7785;
  D.7787 = D.7784 & D.7786;
  dest->data[i] = D.7787;
  i = i + 1;
  <D.7457>:
  if (i < size) goto <D.7456>; else goto <D.7458>;
  <D.7458>:
}


mono_bitset_equal (const struct MonoBitSet * src, const struct MonoBitSet * src1)
{
  unsigned int D.7788;
  unsigned int D.7789;
  gboolean D.7792;
  unsigned int D.7793;
  unsigned int D.7794;
  unsigned int i.21;
  unsigned int D.7798;
  int i;

  D.7788 = src->size;
  D.7789 = src1->size;
  if (D.7788 != D.7789) goto <D.7790>; else goto <D.7791>;
  <D.7790>:
  D.7792 = 0;
  return D.7792;
  <D.7791>:
  i = 0;
  goto <D.7465>;
  <D.7464>:
  D.7793 = src->data[i];
  D.7794 = src1->data[i];
  if (D.7793 != D.7794) goto <D.7795>; else goto <D.7796>;
  <D.7795>:
  D.7792 = 0;
  return D.7792;
  <D.7796>:
  i = i + 1;
  <D.7465>:
  i.21 = (unsigned int) i;
  D.7788 = src->size;
  D.7798 = D.7788 / 32;
  if (i.21 < D.7798) goto <D.7464>; else goto <D.7466>;
  <D.7466>:
  D.7792 = 1;
  return D.7792;
}


mono_bitset_foreach (struct MonoBitSet * set, void (*MonoBitSetFunc) (guint, void *) func, void * data)
{
  unsigned int D.7800;
  unsigned int D.7803;
  unsigned int D.7804;
  unsigned int i.22;
  unsigned int D.7808;
  unsigned int j.23;
  unsigned int D.7810;
  unsigned int i.24;
  unsigned int D.7812;
  unsigned int D.7813;
  int i;
  int j;

  i = 0;
  goto <D.7478>;
  <D.7477>:
  D.7800 = set->data[i];
  if (D.7800 != 0) goto <D.7801>; else goto <D.7802>;
  <D.7801>:
  j = 0;
  goto <D.7475>;
  <D.7474>:
  D.7800 = set->data[i];
  D.7803 = 1 << j;
  D.7804 = D.7800 & D.7803;
  if (D.7804 != 0) goto <D.7805>; else goto <D.7806>;
  <D.7805>:
  i.22 = (unsigned int) i;
  D.7808 = i.22 * 32;
  j.23 = (unsigned int) j;
  D.7810 = D.7808 + j.23;
  func (D.7810, data);
  <D.7806>:
  j = j + 1;
  <D.7475>:
  j.23 = (unsigned int) j;
  if (j.23 <= 31) goto <D.7474>; else goto <D.7476>;
  <D.7476>:
  <D.7802>:
  i = i + 1;
  <D.7478>:
  i.24 = (unsigned int) i;
  D.7812 = set->size;
  D.7813 = D.7812 / 32;
  if (i.24 < D.7813) goto <D.7477>; else goto <D.7479>;
  <D.7479>:
}