mono_bitset_alloc_size (guint32 max_size, guint32 flags)
{
  unsigned int D.4869;
  guint32 D.4870;
  unsigned int D.4871;
  guint32 real_size;

  D.4869 = max_size + 31;
  real_size = D.4869 / 32;
  D.4871 = real_size + 2;
  D.4870 = D.4871 * 4;
  return D.4870;
}


mono_bitset_new (guint32 max_size, guint32 flags)
{
  unsigned int D.4873;
  unsigned int D.4874;
  unsigned int D.4875;
  unsigned int D.4876;
  struct MonoBitSet * D.4877;
  guint32 real_size;
  struct MonoBitSet * result;

  D.4873 = max_size + 31;
  real_size = D.4873 / 32;
  D.4874 = real_size + 2;
  D.4875 = D.4874 * 4;
  result = monoeg_malloc0 (D.4875);
  D.4876 = real_size * 32;
  result->size = D.4876;
  result->flags = flags;
  D.4877 = result;
  return D.4877;
}


mono_bitset_mem_new (void * mem, guint32 max_size, guint32 flags)
{
  unsigned int D.4879;
  unsigned int D.4880;
  unsigned int D.4881;
  struct MonoBitSet * D.4882;
  guint32 real_size;
  struct MonoBitSet * result;

  D.4879 = max_size + 31;
  real_size = D.4879 / 32;
  result = mem;
  D.4880 = real_size * 32;
  result->size = D.4880;
  D.4881 = flags | 1;
  result->flags = D.4881;
  D.4882 = result;
  return D.4882;
}


mono_bitset_free (struct MonoBitSet * set)
{
  unsigned int D.4884;
  unsigned int D.4885;

  D.4884 = set->flags;
  D.4885 = D.4884 & 1;
  if (D.4885 == 0) goto <D.4886>; else goto <D.4887>;
  <D.4886>:
  monoeg_g_free (set);
  <D.4887>:
}


mono_bitset_set (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4888;
  int pos.0;
  unsigned int D.4890;
  _Bool D.4891;
  long int D.4892;
  long int D.4893;
  unsigned int D.4896;
  unsigned int D.4897;
  unsigned int D.4898;
  int j;
  int bit;

  D.4888 = pos / 32;
  j = (int) D.4888;
  pos.0 = (int) pos;
  bit = pos.0 & 31;
  D.4890 = set->size;
  D.4891 = D.4890 <= pos;
  D.4892 = (long int) D.4891;
  D.4893 = __builtin_expect (D.4892, 0);
  if (D.4893 != 0) goto <D.4894>; else goto <D.4895>;
  <D.4894>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 90, "pos < set->size");
  <D.4895>:
  D.4896 = set->data[j];
  D.4897 = 1 << bit;
  D.4898 = D.4896 | D.4897;
  set->data[j] = D.4898;
}


mono_bitset_test (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4899;
  int pos.1;
  unsigned int D.4901;
  int D.4904;
  unsigned int D.4905;
  unsigned int D.4906;
  unsigned int D.4907;
  _Bool D.4908;
  int j;
  int bit;

  D.4899 = pos / 32;
  j = (int) D.4899;
  pos.1 = (int) pos;
  bit = pos.1 & 31;
  D.4901 = set->size;
  if (D.4901 <= pos) goto <D.4902>; else goto <D.4903>;
  <D.4902>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 108, "pos < set->size");
  D.4904 = 0;
  return D.4904;
  <D.4903>:
  D.4905 = set->data[j];
  D.4906 = D.4905 >> bit;
  D.4907 = D.4906 & 1;
  D.4908 = D.4907 != 0;
  D.4904 = (int) D.4908;
  return D.4904;
}


mono_bitset_test_bulk (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4910;
  unsigned int D.4911;
  gsize D.4914;
  int j;

  D.4910 = pos / 32;
  j = (int) D.4910;
  D.4911 = set->size;
  if (D.4911 <= pos) goto <D.4912>; else goto <D.4913>;
  <D.4912>:
  D.4914 = 0;
  return D.4914;
  <D.4913>:
  D.4914 = set->data[j];
  return D.4914;
}


mono_bitset_clear (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4916;
  int pos.2;
  unsigned int D.4918;
  _Bool D.4919;
  long int D.4920;
  long int D.4921;
  unsigned int D.4924;
  unsigned int D.4925;
  unsigned int D.4926;
  unsigned int D.4927;
  int j;
  int bit;

  D.4916 = pos / 32;
  j = (int) D.4916;
  pos.2 = (int) pos;
  bit = pos.2 & 31;
  D.4918 = set->size;
  D.4919 = D.4918 <= pos;
  D.4920 = (long int) D.4919;
  D.4921 = __builtin_expect (D.4920, 0);
  if (D.4921 != 0) goto <D.4922>; else goto <D.4923>;
  <D.4922>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 143, "pos < set->size");
  <D.4923>:
  D.4924 = set->data[j];
  D.4925 = 1 << bit;
  D.4926 = ~D.4925;
  D.4927 = D.4924 & D.4926;
  set->data[j] = D.4927;
}


mono_bitset_clear_all (struct MonoBitSet * set)
{
  unsigned int D.4928;
  unsigned int D.4929;
  gsize[0:] * D.4930;

  D.4928 = set->size;
  D.4929 = D.4928 / 8;
  D.4930 = &set->data;
  memset (D.4930, 0, D.4929);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4933;
  int D.4938;
  void * D.4940;
  unsigned int D.4941;

  D.4933 = __builtin_constant_p (__len);
  if (D.4933 != 0) goto <D.4934>; else goto <D.4935>;
  <D.4934>:
  if (__len == 0) goto <D.4936>; else goto <D.4937>;
  <D.4936>:
  D.4938 = __builtin_constant_p (__ch);
  if (D.4938 == 0) goto <D.4931>; else goto <D.4939>;
  <D.4939>:
  if (__ch != 0) goto <D.4931>; else goto <D.4932>;
  <D.4931>:
  __warn_memset_zero_len ();
  D.4940 = __dest;
  return D.4940;
  <D.4932>:
  <D.4937>:
  <D.4935>:
  D.4941 = __builtin_object_size (__dest, 0);
  D.4940 = __builtin___memset_chk (__dest, __ch, __len, D.4941);
  return D.4940;
}


mono_bitset_set_all (struct MonoBitSet * set)
{
  unsigned int D.4943;
  unsigned int D.4944;
  gsize[0:] * D.4945;

  D.4943 = set->size;
  D.4944 = D.4943 / 8;
  D.4945 = &set->data;
  memset (D.4945, -1, D.4944);
}


mono_bitset_invert (struct MonoBitSet * set)
{
  unsigned int D.4946;
  unsigned int D.4947;
  unsigned int i.3;
  unsigned int D.4949;
  unsigned int D.4950;
  int i;

  i = 0;
  goto <D.4722>;
  <D.4721>:
  D.4946 = set->data[i];
  D.4947 = ~D.4946;
  set->data[i] = D.4947;
  i = i + 1;
  <D.4722>:
  i.3 = (unsigned int) i;
  D.4949 = set->size;
  D.4950 = D.4949 / 32;
  if (i.3 < D.4950) goto <D.4721>; else goto <D.4723>;
  <D.4723>:
}


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

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


mono_bitset_count (const struct MonoBitSet * set)
{
  int D.4955;
  unsigned int D.4956;
  int D.4958;
  unsigned int D.4959;
  unsigned int D.4960;
  unsigned int D.4961;
  guint32 D.4962;
  guint32 i;
  guint32 count;
  gsize d;

  count = 0;
  i = 0;
  goto <D.4734>;
  <D.4733>:
  d = set->data[i];
  if (1 != 0) goto <D.4953>; else goto <D.4954>;
  <D.4953>:
  D.4955 = __builtin_popcountl (d);
  D.4956 = (unsigned int) D.4955;
  count = D.4956 + count;
  goto <D.4957>;
  <D.4954>:
  D.4958 = __builtin_popcount (d);
  D.4959 = (unsigned int) D.4958;
  count = D.4959 + count;
  <D.4957>:
  i = i + 1;
  <D.4734>:
  D.4960 = set->size;
  D.4961 = D.4960 / 32;
  if (D.4961 > i) goto <D.4733>; else goto <D.4735>;
  <D.4735>:
  D.4962 = count;
  return D.4962;
}


mono_bitset_find_start (const struct MonoBitSet * set)
{
  unsigned int D.4964;
  int D.4967;
  int D.4968;
  unsigned int D.4969;
  unsigned int i.4;
  unsigned int D.4971;
  unsigned int D.4972;
  unsigned int D.4973;
  unsigned int D.4974;
  int i;

  i = 0;
  goto <D.4766>;
  <D.4765>:
  D.4964 = set->data[i];
  if (D.4964 != 0) goto <D.4965>; else goto <D.4966>;
  <D.4965>:
  D.4964 = set->data[i];
  D.4968 = my_g_bit_nth_lsf_nomask (D.4964);
  D.4969 = (unsigned int) D.4968;
  i.4 = (unsigned int) i;
  D.4971 = i.4 * 32;
  D.4972 = D.4969 + D.4971;
  D.4967 = (int) D.4972;
  return D.4967;
  <D.4966>:
  i = i + 1;
  <D.4766>:
  i.4 = (unsigned int) i;
  D.4973 = set->size;
  D.4974 = D.4973 / 32;
  if (i.4 < D.4974) goto <D.4765>; else goto <D.4767>;
  <D.4767>:
  D.4967 = -1;
  return D.4967;
}


my_g_bit_nth_lsf_nomask (gsize mask)
{
  gint D.4976;
  int r;

  __asm__("bsfl %1,%0
	" : "=r" r : "rm" mask);
  D.4976 = r;
  return D.4976;
}


mono_bitset_find_first (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.5;
  unsigned int D.4982;
  unsigned int D.4983;
  _Bool D.4984;
  long int D.4985;
  long int D.4986;
  unsigned int D.4989;
  int D.4994;
  unsigned int j.6;
  unsigned int D.4996;
  unsigned int result.7;
  unsigned int D.4998;
  unsigned int D.4999;
  int D.5002;
  unsigned int D.5003;
  unsigned int i.8;
  unsigned int D.5005;
  unsigned int D.5006;
  unsigned int D.5007;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.4978>; else goto <D.4979>;
  <D.4978>:
  j = 0;
  bit = -1;
  goto <D.4980>;
  <D.4979>:
  pos.5 = (unsigned int) pos;
  D.4982 = pos.5 / 32;
  j = (int) D.4982;
  bit = pos & 31;
  pos.5 = (unsigned int) pos;
  D.4983 = set->size;
  D.4984 = pos.5 >= D.4983;
  D.4985 = (long int) D.4984;
  D.4986 = __builtin_expect (D.4985, 0);
  if (D.4986 != 0) goto <D.4987>; else goto <D.4988>;
  <D.4987>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 424, "pos < set->size");
  <D.4988>:
  <D.4980>:
  D.4989 = set->data[j];
  if (D.4989 != 0) goto <D.4990>; else goto <D.4991>;
  <D.4990>:
  D.4989 = set->data[j];
  result = my_g_bit_nth_lsf (D.4989, bit);
  if (result != -1) goto <D.4992>; else goto <D.4993>;
  <D.4992>:
  j.6 = (unsigned int) j;
  D.4996 = j.6 * 32;
  result.7 = (unsigned int) result;
  D.4998 = D.4996 + result.7;
  D.4994 = (int) D.4998;
  return D.4994;
  <D.4993>:
  <D.4991>:
  j = j + 1;
  i = j;
  goto <D.4777>;
  <D.4776>:
  D.4999 = set->data[i];
  if (D.4999 != 0) goto <D.5000>; else goto <D.5001>;
  <D.5000>:
  D.4999 = set->data[i];
  D.5002 = my_g_bit_nth_lsf (D.4999, -1);
  D.5003 = (unsigned int) D.5002;
  i.8 = (unsigned int) i;
  D.5005 = i.8 * 32;
  D.5006 = D.5003 + D.5005;
  D.4994 = (int) D.5006;
  return D.4994;
  <D.5001>:
  i = i + 1;
  <D.4777>:
  i.8 = (unsigned int) i;
  D.4983 = set->size;
  D.5007 = D.4983 / 32;
  if (i.8 < D.5007) goto <D.4776>; else goto <D.4778>;
  <D.4778>:
  D.4994 = -1;
  return D.4994;
}


my_g_bit_nth_lsf (gsize mask, gint nth_bit)
{
  _Bool D.5009;
  _Bool D.5010;
  _Bool D.5011;
  gint D.5014;

  nth_bit = nth_bit + 1;
  mask = mask >> nth_bit;
  D.5009 = mask == 0;
  D.5010 = nth_bit == 32;
  D.5011 = D.5009 | D.5010;
  if (D.5011 != 0) goto <D.5012>; else goto <D.5013>;
  <D.5012>:
  D.5014 = -1;
  return D.5014;
  <D.5013>:
  {
    int r;

    __asm__("bsfl %1,%0
	" : "=r" r : "g" mask);
    D.5014 = nth_bit + r;
    return D.5014;
  }
}


mono_bitset_find_last (const struct MonoBitSet * set, gint pos)
{
  unsigned int D.5018;
  unsigned int D.5019;
  unsigned int pos.9;
  unsigned int D.5021;
  int D.5024;
  unsigned int D.5025;
  unsigned int j.10;
  unsigned int D.5031;
  unsigned int result.11;
  unsigned int D.5033;
  unsigned int D.5034;
  int D.5037;
  unsigned int D.5038;
  unsigned int i.12;
  unsigned int D.5040;
  unsigned int D.5041;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5016>; else goto <D.5017>;
  <D.5016>:
  D.5018 = set->size;
  D.5019 = D.5018 + 4294967295;
  pos = (gint) D.5019;
  <D.5017>:
  pos.9 = (unsigned int) pos;
  D.5021 = pos.9 / 32;
  j = (int) D.5021;
  bit = pos & 31;
  pos.9 = (unsigned int) pos;
  D.5018 = set->size;
  if (pos.9 >= D.5018) goto <D.5022>; else goto <D.5023>;
  <D.5022>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 458, "pos < set->size");
  D.5024 = -1;
  return D.5024;
  <D.5023>:
  D.5025 = set->data[j];
  if (D.5025 != 0) goto <D.5026>; else goto <D.5027>;
  <D.5026>:
  D.5025 = set->data[j];
  result = my_g_bit_nth_msf (D.5025, bit);
  if (result != -1) goto <D.5028>; else goto <D.5029>;
  <D.5028>:
  j.10 = (unsigned int) j;
  D.5031 = j.10 * 32;
  result.11 = (unsigned int) result;
  D.5033 = D.5031 + result.11;
  D.5024 = (int) D.5033;
  return D.5024;
  <D.5029>:
  <D.5027>:
  j = j + -1;
  i = j;
  goto <D.4788>;
  <D.4787>:
  D.5034 = set->data[i];
  if (D.5034 != 0) goto <D.5035>; else goto <D.5036>;
  <D.5035>:
  D.5034 = set->data[i];
  D.5037 = my_g_bit_nth_msf (D.5034, 32);
  D.5038 = (unsigned int) D.5037;
  i.12 = (unsigned int) i;
  D.5040 = i.12 * 32;
  D.5041 = D.5038 + D.5040;
  D.5024 = (int) D.5041;
  return D.5024;
  <D.5036>:
  i = i + -1;
  <D.4788>:
  if (i >= 0) goto <D.4787>; else goto <D.4789>;
  <D.4789>:
  D.5024 = -1;
  return D.5024;
}


my_g_bit_nth_msf (gsize mask, gint nth_bit)
{
  int D.5045;
  unsigned int nth_bit.13;
  unsigned int D.5047;
  int D.5048;
  unsigned int D.5050;
  signed int mask.14;
  unsigned int i.15;
  unsigned int D.5057;
  unsigned int D.5058;
  int i;

  if (nth_bit == 0) goto <D.5043>; else goto <D.5044>;
  <D.5043>:
  D.5045 = -1;
  return D.5045;
  <D.5044>:
  nth_bit.13 = (unsigned int) nth_bit;
  D.5047 = 32 - nth_bit.13;
  D.5048 = (int) D.5047;
  mask = mask << D.5048;
  i = 32;
  goto <D.4751>;
  <D.4750>:
  mask = mask << 8;
  i = i + -8;
  <D.4751>:
  if (i > 0) goto <D.5049>; else goto <D.4752>;
  <D.5049>:
  D.5050 = mask >> 24;
  if (D.5050 == 0) goto <D.4750>; else goto <D.4752>;
  <D.4752>:
  if (mask == 0) goto <D.5051>; else goto <D.5052>;
  <D.5051>:
  D.5045 = -1;
  return D.5045;
  <D.5052>:
  <D.4753>:
  i = i + -1;
  mask.14 = (signed int) mask;
  if (mask.14 < 0) goto <D.5054>; else goto <D.5055>;
  <D.5054>:
  nth_bit.13 = (unsigned int) nth_bit;
  i.15 = (unsigned int) i;
  D.5057 = nth_bit.13 + i.15;
  D.5058 = D.5057 + 4294967264;
  D.5045 = (int) D.5058;
  return D.5045;
  <D.5055>:
  mask = mask << 1;
  if (mask != 0) goto <D.4753>; else goto <D.4754>;
  <D.4754>:
  D.5045 = -1;
  return D.5045;
}


mono_bitset_find_first_unset (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.16;
  unsigned int D.5064;
  unsigned int D.5065;
  int D.5068;
  unsigned int D.5069;
  unsigned int j.17;
  unsigned int D.5075;
  unsigned int result.18;
  unsigned int D.5077;
  unsigned int D.5078;
  int D.5081;
  unsigned int D.5082;
  unsigned int i.19;
  unsigned int D.5084;
  unsigned int D.5085;
  unsigned int D.5086;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5060>; else goto <D.5061>;
  <D.5060>:
  j = 0;
  bit = -1;
  goto <D.5062>;
  <D.5061>:
  pos.16 = (unsigned int) pos;
  D.5064 = pos.16 / 32;
  j = (int) D.5064;
  bit = pos & 31;
  pos.16 = (unsigned int) pos;
  D.5065 = set->size;
  if (pos.16 >= D.5065) goto <D.5066>; else goto <D.5067>;
  <D.5066>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 492, "pos < set->size");
  D.5068 = -1;
  return D.5068;
  <D.5067>:
  <D.5062>:
  D.5069 = set->data[j];
  if (D.5069 != 4294967295) goto <D.5070>; else goto <D.5071>;
  <D.5070>:
  D.5069 = set->data[j];
  result = find_first_unset (D.5069, bit);
  if (result != -1) goto <D.5072>; else goto <D.5073>;
  <D.5072>:
  j.17 = (unsigned int) j;
  D.5075 = j.17 * 32;
  result.18 = (unsigned int) result;
  D.5077 = D.5075 + result.18;
  D.5068 = (int) D.5077;
  return D.5068;
  <D.5073>:
  <D.5071>:
  j = j + 1;
  i = j;
  goto <D.4799>;
  <D.4798>:
  D.5078 = set->data[i];
  if (D.5078 != 4294967295) goto <D.5079>; else goto <D.5080>;
  <D.5079>:
  D.5078 = set->data[i];
  D.5081 = find_first_unset (D.5078, -1);
  D.5082 = (unsigned int) D.5081;
  i.19 = (unsigned int) i;
  D.5084 = i.19 * 32;
  D.5085 = D.5082 + D.5084;
  D.5068 = (int) D.5085;
  return D.5068;
  <D.5080>:
  i = i + 1;
  <D.4799>:
  i.19 = (unsigned int) i;
  D.5065 = set->size;
  D.5086 = D.5065 / 32;
  if (i.19 < D.5086) goto <D.4798>; else goto <D.4800>;
  <D.4800>:
  D.5068 = -1;
  return D.5068;
}


find_first_unset (gsize mask, gint nth_bit)
{
  unsigned int D.5088;
  unsigned int D.5089;
  int D.5094;
  unsigned int nth_bit.20;

  <D.4759>:
  nth_bit = nth_bit + 1;
  D.5088 = 1 << nth_bit;
  D.5089 = D.5088 & mask;
  if (D.5089 == 0) goto <D.5090>; else goto <D.5091>;
  <D.5090>:
  if (nth_bit == 32) goto <D.5092>; else goto <D.5093>;
  <D.5092>:
  D.5094 = -1;
  return D.5094;
  <D.5093>:
  D.5094 = nth_bit;
  return D.5094;
  <D.5091>:
  nth_bit.20 = (unsigned int) nth_bit;
  if (nth_bit.20 <= 31) goto <D.4759>; else goto <D.4760>;
  <D.4760>:
  D.5094 = -1;
  return D.5094;
}


mono_bitset_clone (const struct MonoBitSet * set, guint32 new_size)
{
  unsigned int D.5099;
  unsigned int D.5100;
  unsigned int D.5101;
  unsigned int D.5102;
  unsigned int D.5103;
  const gsize[0:] * D.5104;
  gsize[0:] * D.5105;
  struct MonoBitSet * D.5106;
  struct MonoBitSet * result;

  if (new_size == 0) goto <D.5097>; else goto <D.5098>;
  <D.5097>:
  new_size = set->size;
  <D.5098>:
  D.5099 = set->flags;
  result = mono_bitset_new (new_size, D.5099);
  D.5100 = result->flags;
  D.5101 = D.5100 & 4294967294;
  result->flags = D.5101;
  D.5102 = set->size;
  D.5103 = D.5102 / 8;
  D.5104 = &set->data;
  D.5105 = &result->data;
  memcpy (D.5105, D.5104, D.5103);
  D.5106 = result;
  return D.5106;
}


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

  D.5109 = __builtin_object_size (__dest, 0);
  D.5108 = __builtin___memcpy_chk (__dest, __src, __len, D.5109);
  return D.5108;
}


mono_bitset_copyto (const struct MonoBitSet * src, struct MonoBitSet * dest)
{
  unsigned int D.5111;
  unsigned int D.5112;
  _Bool D.5113;
  long int D.5114;
  long int D.5115;
  unsigned int D.5118;
  const gsize[0:] * D.5119;
  gsize[0:] * D.5120;

  D.5111 = dest->size;
  D.5112 = src->size;
  D.5113 = D.5111 > D.5112;
  D.5114 = (long int) D.5113;
  D.5115 = __builtin_expect (D.5114, 0);
  if (D.5115 != 0) goto <D.5116>; else goto <D.5117>;
  <D.5116>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 539, "dest->size <= src->size");
  <D.5117>:
  D.5111 = dest->size;
  D.5118 = D.5111 / 8;
  D.5119 = &src->data;
  D.5120 = &dest->data;
  memcpy (D.5120, D.5119, D.5118);
}


mono_bitset_union (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5121;
  unsigned int D.5122;
  _Bool D.5123;
  long int D.5124;
  long int D.5125;
  unsigned int D.5128;
  unsigned int D.5129;
  unsigned int D.5130;
  unsigned int D.5131;
  int i;
  int size;

  D.5121 = src->size;
  D.5122 = dest->size;
  D.5123 = D.5121 > D.5122;
  D.5124 = (long int) D.5123;
  D.5125 = __builtin_expect (D.5124, 0);
  if (D.5125 != 0) goto <D.5126>; else goto <D.5127>;
  <D.5126>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 555, "src->size <= dest->size");
  <D.5127>:
  D.5122 = dest->size;
  D.5128 = D.5122 / 32;
  size = (int) D.5128;
  i = 0;
  goto <D.4817>;
  <D.4816>:
  D.5129 = dest->data[i];
  D.5130 = src->data[i];
  D.5131 = D.5129 | D.5130;
  dest->data[i] = D.5131;
  i = i + 1;
  <D.4817>:
  if (i < size) goto <D.4816>; else goto <D.4818>;
  <D.4818>:
}


mono_bitset_intersection (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5132;
  unsigned int D.5133;
  _Bool D.5134;
  long int D.5135;
  long int D.5136;
  unsigned int D.5139;
  unsigned int D.5140;
  unsigned int D.5141;
  unsigned int D.5142;
  int i;
  int size;

  D.5132 = src->size;
  D.5133 = dest->size;
  D.5134 = D.5132 > D.5133;
  D.5135 = (long int) D.5134;
  D.5136 = __builtin_expect (D.5135, 0);
  if (D.5136 != 0) goto <D.5137>; else goto <D.5138>;
  <D.5137>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 573, "src->size <= dest->size");
  <D.5138>:
  D.5133 = dest->size;
  D.5139 = D.5133 / 32;
  size = (int) D.5139;
  i = 0;
  goto <D.4826>;
  <D.4825>:
  D.5140 = dest->data[i];
  D.5141 = src->data[i];
  D.5142 = D.5140 & D.5141;
  dest->data[i] = D.5142;
  i = i + 1;
  <D.4826>:
  if (i < size) goto <D.4825>; else goto <D.4827>;
  <D.4827>:
}


mono_bitset_intersection_2 (struct MonoBitSet * dest, const struct MonoBitSet * src1, const struct MonoBitSet * src2)
{
  unsigned int D.5143;
  unsigned int D.5144;
  _Bool D.5145;
  long int D.5146;
  long int D.5147;
  unsigned int D.5150;
  _Bool D.5151;
  long int D.5152;
  long int D.5153;
  unsigned int D.5156;
  unsigned int D.5157;
  unsigned int D.5158;
  unsigned int D.5159;
  int i;
  int size;

  D.5143 = src1->size;
  D.5144 = dest->size;
  D.5145 = D.5143 > D.5144;
  D.5146 = (long int) D.5145;
  D.5147 = __builtin_expect (D.5146, 0);
  if (D.5147 != 0) goto <D.5148>; else goto <D.5149>;
  <D.5148>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 592, "src1->size <= dest->size");
  <D.5149>:
  D.5150 = src2->size;
  D.5144 = dest->size;
  D.5151 = D.5150 > D.5144;
  D.5152 = (long int) D.5151;
  D.5153 = __builtin_expect (D.5152, 0);
  if (D.5153 != 0) goto <D.5154>; else goto <D.5155>;
  <D.5154>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 593, "src2->size <= dest->size");
  <D.5155>:
  D.5144 = dest->size;
  D.5156 = D.5144 / 32;
  size = (int) D.5156;
  i = 0;
  goto <D.4836>;
  <D.4835>:
  D.5157 = src1->data[i];
  D.5158 = src2->data[i];
  D.5159 = D.5157 & D.5158;
  dest->data[i] = D.5159;
  i = i + 1;
  <D.4836>:
  if (i < size) goto <D.4835>; else goto <D.4837>;
  <D.4837>:
}


mono_bitset_sub (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5160;
  unsigned int D.5161;
  _Bool D.5162;
  long int D.5163;
  long int D.5164;
  unsigned int D.5167;
  unsigned int D.5168;
  unsigned int D.5169;
  unsigned int D.5170;
  unsigned int D.5171;
  int i;
  int size;

  D.5160 = src->size;
  D.5161 = dest->size;
  D.5162 = D.5160 > D.5161;
  D.5163 = (long int) D.5162;
  D.5164 = __builtin_expect (D.5163, 0);
  if (D.5164 != 0) goto <D.5165>; else goto <D.5166>;
  <D.5165>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 611, "src->size <= dest->size");
  <D.5166>:
  D.5160 = src->size;
  D.5167 = D.5160 / 32;
  size = (int) D.5167;
  i = 0;
  goto <D.4845>;
  <D.4844>:
  D.5168 = dest->data[i];
  D.5169 = src->data[i];
  D.5170 = ~D.5169;
  D.5171 = D.5168 & D.5170;
  dest->data[i] = D.5171;
  i = i + 1;
  <D.4845>:
  if (i < size) goto <D.4844>; else goto <D.4846>;
  <D.4846>:
}


mono_bitset_equal (const struct MonoBitSet * src, const struct MonoBitSet * src1)
{
  unsigned int D.5172;
  unsigned int D.5173;
  gboolean D.5176;
  unsigned int D.5177;
  unsigned int D.5178;
  unsigned int i.21;
  unsigned int D.5182;
  int i;

  D.5172 = src->size;
  D.5173 = src1->size;
  if (D.5172 != D.5173) goto <D.5174>; else goto <D.5175>;
  <D.5174>:
  D.5176 = 0;
  return D.5176;
  <D.5175>:
  i = 0;
  goto <D.4853>;
  <D.4852>:
  D.5177 = src->data[i];
  D.5178 = src1->data[i];
  if (D.5177 != D.5178) goto <D.5179>; else goto <D.5180>;
  <D.5179>:
  D.5176 = 0;
  return D.5176;
  <D.5180>:
  i = i + 1;
  <D.4853>:
  i.21 = (unsigned int) i;
  D.5172 = src->size;
  D.5182 = D.5172 / 32;
  if (i.21 < D.5182) goto <D.4852>; else goto <D.4854>;
  <D.4854>:
  D.5176 = 1;
  return D.5176;
}


mono_bitset_foreach (struct MonoBitSet * set, void (*MonoBitSetFunc) (guint, void *) func, void * data)
{
  unsigned int D.5184;
  unsigned int D.5187;
  unsigned int D.5188;
  unsigned int i.22;
  unsigned int D.5192;
  unsigned int j.23;
  unsigned int D.5194;
  unsigned int i.24;
  unsigned int D.5196;
  unsigned int D.5197;
  int i;
  int j;

  i = 0;
  goto <D.4866>;
  <D.4865>:
  D.5184 = set->data[i];
  if (D.5184 != 0) goto <D.5185>; else goto <D.5186>;
  <D.5185>:
  j = 0;
  goto <D.4863>;
  <D.4862>:
  D.5184 = set->data[i];
  D.5187 = 1 << j;
  D.5188 = D.5184 & D.5187;
  if (D.5188 != 0) goto <D.5189>; else goto <D.5190>;
  <D.5189>:
  i.22 = (unsigned int) i;
  D.5192 = i.22 * 32;
  j.23 = (unsigned int) j;
  D.5194 = D.5192 + j.23;
  func (D.5194, data);
  <D.5190>:
  j = j + 1;
  <D.4863>:
  j.23 = (unsigned int) j;
  if (j.23 <= 31) goto <D.4862>; else goto <D.4864>;
  <D.4864>:
  <D.5186>:
  i = i + 1;
  <D.4866>:
  i.24 = (unsigned int) i;
  D.5196 = set->size;
  D.5197 = D.5196 / 32;
  if (i.24 < D.5197) goto <D.4865>; else goto <D.4867>;
  <D.4867>:
}