mono_bitset_alloc_size (guint32 max_size, guint32 flags)
{
  unsigned int D.4894;
  guint32 D.4895;
  unsigned int D.4896;
  guint32 real_size;

  D.4894 = max_size + 31;
  real_size = D.4894 / 32;
  D.4896 = real_size + 2;
  D.4895 = D.4896 * 4;
  return D.4895;
}


mono_bitset_new (guint32 max_size, guint32 flags)
{
  unsigned int D.4898;
  unsigned int D.4899;
  unsigned int D.4900;
  unsigned int D.4901;
  struct MonoBitSet * D.4902;
  guint32 real_size;
  struct MonoBitSet * result;

  D.4898 = max_size + 31;
  real_size = D.4898 / 32;
  D.4899 = real_size + 2;
  D.4900 = D.4899 * 4;
  result = monoeg_malloc0 (D.4900);
  D.4901 = real_size * 32;
  result->size = D.4901;
  result->flags = flags;
  D.4902 = result;
  return D.4902;
}


mono_bitset_mem_new (void * mem, guint32 max_size, guint32 flags)
{
  unsigned int D.4904;
  unsigned int D.4905;
  unsigned int D.4906;
  struct MonoBitSet * D.4907;
  guint32 real_size;
  struct MonoBitSet * result;

  D.4904 = max_size + 31;
  real_size = D.4904 / 32;
  result = mem;
  D.4905 = real_size * 32;
  result->size = D.4905;
  D.4906 = flags | 1;
  result->flags = D.4906;
  D.4907 = result;
  return D.4907;
}


mono_bitset_free (struct MonoBitSet * set)
{
  unsigned int D.4909;
  unsigned int D.4910;

  D.4909 = set->flags;
  D.4910 = D.4909 & 1;
  if (D.4910 == 0) goto <D.4911>; else goto <D.4912>;
  <D.4911>:
  monoeg_g_free (set);
  <D.4912>:
}


mono_bitset_set (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4913;
  int pos.0;
  unsigned int D.4915;
  _Bool D.4916;
  long int D.4917;
  long int D.4918;
  unsigned int D.4921;
  unsigned int D.4922;
  unsigned int D.4923;
  int j;
  int bit;

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


mono_bitset_test (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4924;
  int pos.1;
  unsigned int D.4926;
  int D.4929;
  unsigned int D.4930;
  unsigned int D.4931;
  unsigned int D.4932;
  _Bool D.4933;
  int j;
  int bit;

  D.4924 = pos / 32;
  j = (int) D.4924;
  pos.1 = (int) pos;
  bit = pos.1 & 31;
  D.4926 = set->size;
  if (D.4926 <= pos) goto <D.4927>; else goto <D.4928>;
  <D.4927>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 108, "pos < set->size");
  D.4929 = 0;
  return D.4929;
  <D.4928>:
  D.4930 = set->data[j];
  D.4931 = D.4930 >> bit;
  D.4932 = D.4931 & 1;
  D.4933 = D.4932 != 0;
  D.4929 = (int) D.4933;
  return D.4929;
}


mono_bitset_test_bulk (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4935;
  unsigned int D.4936;
  gsize D.4939;
  int j;

  D.4935 = pos / 32;
  j = (int) D.4935;
  D.4936 = set->size;
  if (D.4936 <= pos) goto <D.4937>; else goto <D.4938>;
  <D.4937>:
  D.4939 = 0;
  return D.4939;
  <D.4938>:
  D.4939 = set->data[j];
  return D.4939;
}


mono_bitset_clear (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.4941;
  int pos.2;
  unsigned int D.4943;
  _Bool D.4944;
  long int D.4945;
  long int D.4946;
  unsigned int D.4949;
  unsigned int D.4950;
  unsigned int D.4951;
  unsigned int D.4952;
  int j;
  int bit;

  D.4941 = pos / 32;
  j = (int) D.4941;
  pos.2 = (int) pos;
  bit = pos.2 & 31;
  D.4943 = set->size;
  D.4944 = D.4943 <= pos;
  D.4945 = (long int) D.4944;
  D.4946 = __builtin_expect (D.4945, 0);
  if (D.4946 != 0) goto <D.4947>; else goto <D.4948>;
  <D.4947>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 143, "pos < set->size");
  <D.4948>:
  D.4949 = set->data[j];
  D.4950 = 1 << bit;
  D.4951 = ~D.4950;
  D.4952 = D.4949 & D.4951;
  set->data[j] = D.4952;
}


mono_bitset_clear_all (struct MonoBitSet * set)
{
  gsize[0:] * D.4953;
  unsigned int D.4954;
  unsigned int D.4955;

  D.4953 = &set->data;
  D.4954 = set->size;
  D.4955 = D.4954 / 8;
  memset (D.4953, 0, D.4955);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4958;
  int D.4963;
  void * D.4965;
  unsigned int D.4966;

  D.4958 = __builtin_constant_p (__len);
  if (D.4958 != 0) goto <D.4959>; else goto <D.4960>;
  <D.4959>:
  if (__len == 0) goto <D.4961>; else goto <D.4962>;
  <D.4961>:
  D.4963 = __builtin_constant_p (__ch);
  if (D.4963 == 0) goto <D.4956>; else goto <D.4964>;
  <D.4964>:
  if (__ch != 0) goto <D.4956>; else goto <D.4957>;
  <D.4956>:
  __warn_memset_zero_len ();
  D.4965 = __dest;
  return D.4965;
  <D.4957>:
  <D.4962>:
  <D.4960>:
  D.4966 = __builtin_object_size (__dest, 0);
  D.4965 = __builtin___memset_chk (__dest, __ch, __len, D.4966);
  return D.4965;
}


mono_bitset_set_all (struct MonoBitSet * set)
{
  gsize[0:] * D.4968;
  unsigned int D.4969;
  unsigned int D.4970;

  D.4968 = &set->data;
  D.4969 = set->size;
  D.4970 = D.4969 / 8;
  memset (D.4968, -1, D.4970);
}


mono_bitset_invert (struct MonoBitSet * set)
{
  unsigned int D.4971;
  unsigned int D.4972;
  unsigned int i.3;
  unsigned int D.4974;
  unsigned int D.4975;
  int i;

  i = 0;
  goto <D.4742>;
  <D.4741>:
  D.4971 = set->data[i];
  D.4972 = ~D.4971;
  set->data[i] = D.4972;
  i = i + 1;
  <D.4742>:
  i.3 = (unsigned int) i;
  D.4974 = set->size;
  D.4975 = D.4974 / 32;
  if (i.3 < D.4975) goto <D.4741>; else goto <D.4743>;
  <D.4743>:
}


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

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


mono_bitset_count (const struct MonoBitSet * set)
{
  int D.4980;
  unsigned int D.4981;
  int D.4983;
  unsigned int D.4984;
  unsigned int D.4985;
  unsigned int D.4986;
  guint32 D.4987;
  guint32 i;
  guint32 count;
  gsize d;

  count = 0;
  i = 0;
  goto <D.4754>;
  <D.4753>:
  d = set->data[i];
  if (1 != 0) goto <D.4978>; else goto <D.4979>;
  <D.4978>:
  D.4980 = __builtin_popcountl (d);
  D.4981 = (unsigned int) D.4980;
  count = D.4981 + count;
  goto <D.4982>;
  <D.4979>:
  D.4983 = __builtin_popcount (d);
  D.4984 = (unsigned int) D.4983;
  count = D.4984 + count;
  <D.4982>:
  i = i + 1;
  <D.4754>:
  D.4985 = set->size;
  D.4986 = D.4985 / 32;
  if (D.4986 > i) goto <D.4753>; else goto <D.4755>;
  <D.4755>:
  D.4987 = count;
  return D.4987;
}


mono_bitset_find_start (const struct MonoBitSet * set)
{
  unsigned int D.4989;
  int D.4992;
  int D.4993;
  unsigned int D.4994;
  unsigned int i.4;
  unsigned int D.4996;
  unsigned int D.4997;
  unsigned int D.4998;
  unsigned int D.4999;
  int i;

  i = 0;
  goto <D.4791>;
  <D.4790>:
  D.4989 = set->data[i];
  if (D.4989 != 0) goto <D.4990>; else goto <D.4991>;
  <D.4990>:
  D.4989 = set->data[i];
  D.4993 = my_g_bit_nth_lsf_nomask (D.4989);
  D.4994 = (unsigned int) D.4993;
  i.4 = (unsigned int) i;
  D.4996 = i.4 * 32;
  D.4997 = D.4994 + D.4996;
  D.4992 = (int) D.4997;
  return D.4992;
  <D.4991>:
  i = i + 1;
  <D.4791>:
  i.4 = (unsigned int) i;
  D.4998 = set->size;
  D.4999 = D.4998 / 32;
  if (i.4 < D.4999) goto <D.4790>; else goto <D.4792>;
  <D.4792>:
  D.4992 = -1;
  return D.4992;
}


my_g_bit_nth_lsf_nomask (gsize mask)
{
  unsigned int D.5001;
  gint D.5002;
  int nth_bit;

  nth_bit = 0;
  goto <D.4768>;
  <D.4767>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.4768>:
  D.5001 = mask & 1;
  if (D.5001 == 0) goto <D.4767>; else goto <D.4769>;
  <D.4769>:
  D.5002 = nth_bit;
  return D.5002;
}


mono_bitset_find_first (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.5;
  unsigned int D.5008;
  unsigned int D.5009;
  _Bool D.5010;
  long int D.5011;
  long int D.5012;
  unsigned int D.5015;
  int D.5020;
  unsigned int j.6;
  unsigned int D.5022;
  unsigned int result.7;
  unsigned int D.5024;
  unsigned int D.5025;
  int D.5028;
  unsigned int D.5029;
  unsigned int i.8;
  unsigned int D.5031;
  unsigned int D.5032;
  unsigned int D.5033;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5004>; else goto <D.5005>;
  <D.5004>:
  j = 0;
  bit = -1;
  goto <D.5006>;
  <D.5005>:
  pos.5 = (unsigned int) pos;
  D.5008 = pos.5 / 32;
  j = (int) D.5008;
  bit = pos & 31;
  pos.5 = (unsigned int) pos;
  D.5009 = set->size;
  D.5010 = pos.5 >= D.5009;
  D.5011 = (long int) D.5010;
  D.5012 = __builtin_expect (D.5011, 0);
  if (D.5012 != 0) goto <D.5013>; else goto <D.5014>;
  <D.5013>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 424, "pos < set->size");
  <D.5014>:
  <D.5006>:
  D.5015 = set->data[j];
  if (D.5015 != 0) goto <D.5016>; else goto <D.5017>;
  <D.5016>:
  D.5015 = set->data[j];
  result = my_g_bit_nth_lsf (D.5015, bit);
  if (result != -1) goto <D.5018>; else goto <D.5019>;
  <D.5018>:
  j.6 = (unsigned int) j;
  D.5022 = j.6 * 32;
  result.7 = (unsigned int) result;
  D.5024 = D.5022 + result.7;
  D.5020 = (int) D.5024;
  return D.5020;
  <D.5019>:
  <D.5017>:
  j = j + 1;
  i = j;
  goto <D.4802>;
  <D.4801>:
  D.5025 = set->data[i];
  if (D.5025 != 0) goto <D.5026>; else goto <D.5027>;
  <D.5026>:
  D.5025 = set->data[i];
  D.5028 = my_g_bit_nth_lsf (D.5025, -1);
  D.5029 = (unsigned int) D.5028;
  i.8 = (unsigned int) i;
  D.5031 = i.8 * 32;
  D.5032 = D.5029 + D.5031;
  D.5020 = (int) D.5032;
  return D.5020;
  <D.5027>:
  i = i + 1;
  <D.4802>:
  i.8 = (unsigned int) i;
  D.5009 = set->size;
  D.5033 = D.5009 / 32;
  if (i.8 < D.5033) goto <D.4801>; else goto <D.4803>;
  <D.4803>:
  D.5020 = -1;
  return D.5020;
}


my_g_bit_nth_lsf (gsize mask, gint nth_bit)
{
  gint D.5038;
  unsigned int D.5039;

  nth_bit = nth_bit + 1;
  mask = mask >> nth_bit;
  if (mask == 0) goto <D.5035>; else goto <D.5037>;
  <D.5037>:
  if (nth_bit == 32) goto <D.5035>; else goto <D.5036>;
  <D.5035>:
  D.5038 = -1;
  return D.5038;
  <D.5036>:
  goto <D.4761>;
  <D.4760>:
  mask = mask >> 1;
  nth_bit = nth_bit + 1;
  <D.4761>:
  D.5039 = mask & 1;
  if (D.5039 == 0) goto <D.4760>; else goto <D.4762>;
  <D.4762>:
  D.5038 = nth_bit;
  return D.5038;
}


mono_bitset_find_last (const struct MonoBitSet * set, gint pos)
{
  unsigned int D.5043;
  unsigned int D.5044;
  unsigned int pos.9;
  unsigned int D.5046;
  int D.5049;
  unsigned int D.5050;
  unsigned int j.10;
  unsigned int D.5056;
  unsigned int result.11;
  unsigned int D.5058;
  unsigned int D.5059;
  int D.5062;
  unsigned int D.5063;
  unsigned int i.12;
  unsigned int D.5065;
  unsigned int D.5066;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5041>; else goto <D.5042>;
  <D.5041>:
  D.5043 = set->size;
  D.5044 = D.5043 + 4294967295;
  pos = (gint) D.5044;
  <D.5042>:
  pos.9 = (unsigned int) pos;
  D.5046 = pos.9 / 32;
  j = (int) D.5046;
  bit = pos & 31;
  pos.9 = (unsigned int) pos;
  D.5043 = set->size;
  if (pos.9 >= D.5043) goto <D.5047>; else goto <D.5048>;
  <D.5047>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 458, "pos < set->size");
  D.5049 = -1;
  return D.5049;
  <D.5048>:
  D.5050 = set->data[j];
  if (D.5050 != 0) goto <D.5051>; else goto <D.5052>;
  <D.5051>:
  D.5050 = set->data[j];
  result = my_g_bit_nth_msf (D.5050, bit);
  if (result != -1) goto <D.5053>; else goto <D.5054>;
  <D.5053>:
  j.10 = (unsigned int) j;
  D.5056 = j.10 * 32;
  result.11 = (unsigned int) result;
  D.5058 = D.5056 + result.11;
  D.5049 = (int) D.5058;
  return D.5049;
  <D.5054>:
  <D.5052>:
  j = j + -1;
  i = j;
  goto <D.4813>;
  <D.4812>:
  D.5059 = set->data[i];
  if (D.5059 != 0) goto <D.5060>; else goto <D.5061>;
  <D.5060>:
  D.5059 = set->data[i];
  D.5062 = my_g_bit_nth_msf (D.5059, 32);
  D.5063 = (unsigned int) D.5062;
  i.12 = (unsigned int) i;
  D.5065 = i.12 * 32;
  D.5066 = D.5063 + D.5065;
  D.5049 = (int) D.5066;
  return D.5049;
  <D.5061>:
  i = i + -1;
  <D.4813>:
  if (i >= 0) goto <D.4812>; else goto <D.4814>;
  <D.4814>:
  D.5049 = -1;
  return D.5049;
}


my_g_bit_nth_msf (gsize mask, gint nth_bit)
{
  int D.5070;
  unsigned int nth_bit.13;
  unsigned int D.5072;
  int D.5073;
  unsigned int D.5075;
  signed int mask.14;
  unsigned int i.15;
  unsigned int D.5082;
  unsigned int D.5083;
  int i;

  if (nth_bit == 0) goto <D.5068>; else goto <D.5069>;
  <D.5068>:
  D.5070 = -1;
  return D.5070;
  <D.5069>:
  nth_bit.13 = (unsigned int) nth_bit;
  D.5072 = 32 - nth_bit.13;
  D.5073 = (int) D.5072;
  mask = mask << D.5073;
  i = 32;
  goto <D.4776>;
  <D.4775>:
  mask = mask << 8;
  i = i + -8;
  <D.4776>:
  if (i > 0) goto <D.5074>; else goto <D.4777>;
  <D.5074>:
  D.5075 = mask >> 24;
  if (D.5075 == 0) goto <D.4775>; else goto <D.4777>;
  <D.4777>:
  if (mask == 0) goto <D.5076>; else goto <D.5077>;
  <D.5076>:
  D.5070 = -1;
  return D.5070;
  <D.5077>:
  <D.4778>:
  i = i + -1;
  mask.14 = (signed int) mask;
  if (mask.14 < 0) goto <D.5079>; else goto <D.5080>;
  <D.5079>:
  nth_bit.13 = (unsigned int) nth_bit;
  i.15 = (unsigned int) i;
  D.5082 = nth_bit.13 + i.15;
  D.5083 = D.5082 + 4294967264;
  D.5070 = (int) D.5083;
  return D.5070;
  <D.5080>:
  mask = mask << 1;
  if (mask != 0) goto <D.4778>; else goto <D.4779>;
  <D.4779>:
  D.5070 = -1;
  return D.5070;
}


mono_bitset_find_first_unset (const struct MonoBitSet * set, gint pos)
{
  unsigned int pos.16;
  unsigned int D.5089;
  unsigned int D.5090;
  int D.5093;
  unsigned int D.5094;
  unsigned int j.17;
  unsigned int D.5100;
  unsigned int result.18;
  unsigned int D.5102;
  unsigned int D.5103;
  int D.5106;
  unsigned int D.5107;
  unsigned int i.19;
  unsigned int D.5109;
  unsigned int D.5110;
  unsigned int D.5111;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5085>; else goto <D.5086>;
  <D.5085>:
  j = 0;
  bit = -1;
  goto <D.5087>;
  <D.5086>:
  pos.16 = (unsigned int) pos;
  D.5089 = pos.16 / 32;
  j = (int) D.5089;
  bit = pos & 31;
  pos.16 = (unsigned int) pos;
  D.5090 = set->size;
  if (pos.16 >= D.5090) goto <D.5091>; else goto <D.5092>;
  <D.5091>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 492, "pos < set->size");
  D.5093 = -1;
  return D.5093;
  <D.5092>:
  <D.5087>:
  D.5094 = set->data[j];
  if (D.5094 != 4294967295) goto <D.5095>; else goto <D.5096>;
  <D.5095>:
  D.5094 = set->data[j];
  result = find_first_unset (D.5094, bit);
  if (result != -1) goto <D.5097>; else goto <D.5098>;
  <D.5097>:
  j.17 = (unsigned int) j;
  D.5100 = j.17 * 32;
  result.18 = (unsigned int) result;
  D.5102 = D.5100 + result.18;
  D.5093 = (int) D.5102;
  return D.5093;
  <D.5098>:
  <D.5096>:
  j = j + 1;
  i = j;
  goto <D.4824>;
  <D.4823>:
  D.5103 = set->data[i];
  if (D.5103 != 4294967295) goto <D.5104>; else goto <D.5105>;
  <D.5104>:
  D.5103 = set->data[i];
  D.5106 = find_first_unset (D.5103, -1);
  D.5107 = (unsigned int) D.5106;
  i.19 = (unsigned int) i;
  D.5109 = i.19 * 32;
  D.5110 = D.5107 + D.5109;
  D.5093 = (int) D.5110;
  return D.5093;
  <D.5105>:
  i = i + 1;
  <D.4824>:
  i.19 = (unsigned int) i;
  D.5090 = set->size;
  D.5111 = D.5090 / 32;
  if (i.19 < D.5111) goto <D.4823>; else goto <D.4825>;
  <D.4825>:
  D.5093 = -1;
  return D.5093;
}


find_first_unset (gsize mask, gint nth_bit)
{
  unsigned int D.5113;
  unsigned int D.5114;
  int D.5119;
  unsigned int nth_bit.20;

  <D.4784>:
  nth_bit = nth_bit + 1;
  D.5113 = 1 << nth_bit;
  D.5114 = D.5113 & mask;
  if (D.5114 == 0) goto <D.5115>; else goto <D.5116>;
  <D.5115>:
  if (nth_bit == 32) goto <D.5117>; else goto <D.5118>;
  <D.5117>:
  D.5119 = -1;
  return D.5119;
  <D.5118>:
  D.5119 = nth_bit;
  return D.5119;
  <D.5116>:
  nth_bit.20 = (unsigned int) nth_bit;
  if (nth_bit.20 <= 31) goto <D.4784>; else goto <D.4785>;
  <D.4785>:
  D.5119 = -1;
  return D.5119;
}


mono_bitset_clone (const struct MonoBitSet * set, guint32 new_size)
{
  unsigned int D.5124;
  unsigned int D.5125;
  unsigned int D.5126;
  gsize[0:] * D.5127;
  const gsize[0:] * D.5128;
  unsigned int D.5129;
  unsigned int D.5130;
  struct MonoBitSet * D.5131;
  struct MonoBitSet * result;

  if (new_size == 0) goto <D.5122>; else goto <D.5123>;
  <D.5122>:
  new_size = set->size;
  <D.5123>:
  D.5124 = set->flags;
  result = mono_bitset_new (new_size, D.5124);
  D.5125 = result->flags;
  D.5126 = D.5125 & 4294967294;
  result->flags = D.5126;
  D.5127 = &result->data;
  D.5128 = &set->data;
  D.5129 = set->size;
  D.5130 = D.5129 / 8;
  memcpy (D.5127, D.5128, D.5130);
  D.5131 = result;
  return D.5131;
}


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

  D.5134 = __builtin_object_size (__dest, 0);
  D.5133 = __builtin___memcpy_chk (__dest, __src, __len, D.5134);
  return D.5133;
}


mono_bitset_copyto (const struct MonoBitSet * src, struct MonoBitSet * dest)
{
  unsigned int D.5136;
  unsigned int D.5137;
  _Bool D.5138;
  long int D.5139;
  long int D.5140;
  gsize[0:] * D.5143;
  const gsize[0:] * D.5144;
  unsigned int D.5145;

  D.5136 = dest->size;
  D.5137 = src->size;
  D.5138 = D.5136 > D.5137;
  D.5139 = (long int) D.5138;
  D.5140 = __builtin_expect (D.5139, 0);
  if (D.5140 != 0) goto <D.5141>; else goto <D.5142>;
  <D.5141>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 539, "dest->size <= src->size");
  <D.5142>:
  D.5143 = &dest->data;
  D.5144 = &src->data;
  D.5136 = dest->size;
  D.5145 = D.5136 / 8;
  memcpy (D.5143, D.5144, D.5145);
}


mono_bitset_union (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5146;
  unsigned int D.5147;
  _Bool D.5148;
  long int D.5149;
  long int D.5150;
  unsigned int D.5153;
  unsigned int D.5154;
  unsigned int D.5155;
  unsigned int D.5156;
  int i;
  int size;

  D.5146 = src->size;
  D.5147 = dest->size;
  D.5148 = D.5146 > D.5147;
  D.5149 = (long int) D.5148;
  D.5150 = __builtin_expect (D.5149, 0);
  if (D.5150 != 0) goto <D.5151>; else goto <D.5152>;
  <D.5151>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 555, "src->size <= dest->size");
  <D.5152>:
  D.5147 = dest->size;
  D.5153 = D.5147 / 32;
  size = (int) D.5153;
  i = 0;
  goto <D.4842>;
  <D.4841>:
  D.5154 = dest->data[i];
  D.5155 = src->data[i];
  D.5156 = D.5154 | D.5155;
  dest->data[i] = D.5156;
  i = i + 1;
  <D.4842>:
  if (i < size) goto <D.4841>; else goto <D.4843>;
  <D.4843>:
}


mono_bitset_intersection (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5157;
  unsigned int D.5158;
  _Bool D.5159;
  long int D.5160;
  long int D.5161;
  unsigned int D.5164;
  unsigned int D.5165;
  unsigned int D.5166;
  unsigned int D.5167;
  int i;
  int size;

  D.5157 = src->size;
  D.5158 = dest->size;
  D.5159 = D.5157 > D.5158;
  D.5160 = (long int) D.5159;
  D.5161 = __builtin_expect (D.5160, 0);
  if (D.5161 != 0) goto <D.5162>; else goto <D.5163>;
  <D.5162>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 573, "src->size <= dest->size");
  <D.5163>:
  D.5158 = dest->size;
  D.5164 = D.5158 / 32;
  size = (int) D.5164;
  i = 0;
  goto <D.4851>;
  <D.4850>:
  D.5165 = dest->data[i];
  D.5166 = src->data[i];
  D.5167 = D.5165 & D.5166;
  dest->data[i] = D.5167;
  i = i + 1;
  <D.4851>:
  if (i < size) goto <D.4850>; else goto <D.4852>;
  <D.4852>:
}


mono_bitset_intersection_2 (struct MonoBitSet * dest, const struct MonoBitSet * src1, const struct MonoBitSet * src2)
{
  unsigned int D.5168;
  unsigned int D.5169;
  _Bool D.5170;
  long int D.5171;
  long int D.5172;
  unsigned int D.5175;
  _Bool D.5176;
  long int D.5177;
  long int D.5178;
  unsigned int D.5181;
  unsigned int D.5182;
  unsigned int D.5183;
  unsigned int D.5184;
  int i;
  int size;

  D.5168 = src1->size;
  D.5169 = dest->size;
  D.5170 = D.5168 > D.5169;
  D.5171 = (long int) D.5170;
  D.5172 = __builtin_expect (D.5171, 0);
  if (D.5172 != 0) goto <D.5173>; else goto <D.5174>;
  <D.5173>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 592, "src1->size <= dest->size");
  <D.5174>:
  D.5175 = src2->size;
  D.5169 = dest->size;
  D.5176 = D.5175 > D.5169;
  D.5177 = (long int) D.5176;
  D.5178 = __builtin_expect (D.5177, 0);
  if (D.5178 != 0) goto <D.5179>; else goto <D.5180>;
  <D.5179>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 593, "src2->size <= dest->size");
  <D.5180>:
  D.5169 = dest->size;
  D.5181 = D.5169 / 32;
  size = (int) D.5181;
  i = 0;
  goto <D.4861>;
  <D.4860>:
  D.5182 = src1->data[i];
  D.5183 = src2->data[i];
  D.5184 = D.5182 & D.5183;
  dest->data[i] = D.5184;
  i = i + 1;
  <D.4861>:
  if (i < size) goto <D.4860>; else goto <D.4862>;
  <D.4862>:
}


mono_bitset_sub (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  unsigned int D.5185;
  unsigned int D.5186;
  _Bool D.5187;
  long int D.5188;
  long int D.5189;
  unsigned int D.5192;
  unsigned int D.5193;
  unsigned int D.5194;
  unsigned int D.5195;
  unsigned int D.5196;
  int i;
  int size;

  D.5185 = src->size;
  D.5186 = dest->size;
  D.5187 = D.5185 > D.5186;
  D.5188 = (long int) D.5187;
  D.5189 = __builtin_expect (D.5188, 0);
  if (D.5189 != 0) goto <D.5190>; else goto <D.5191>;
  <D.5190>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 611, "src->size <= dest->size");
  <D.5191>:
  D.5185 = src->size;
  D.5192 = D.5185 / 32;
  size = (int) D.5192;
  i = 0;
  goto <D.4870>;
  <D.4869>:
  D.5193 = dest->data[i];
  D.5194 = src->data[i];
  D.5195 = ~D.5194;
  D.5196 = D.5193 & D.5195;
  dest->data[i] = D.5196;
  i = i + 1;
  <D.4870>:
  if (i < size) goto <D.4869>; else goto <D.4871>;
  <D.4871>:
}


mono_bitset_equal (const struct MonoBitSet * src, const struct MonoBitSet * src1)
{
  unsigned int D.5197;
  unsigned int D.5198;
  gboolean D.5201;
  unsigned int D.5202;
  unsigned int D.5203;
  unsigned int i.21;
  unsigned int D.5207;
  int i;

  D.5197 = src->size;
  D.5198 = src1->size;
  if (D.5197 != D.5198) goto <D.5199>; else goto <D.5200>;
  <D.5199>:
  D.5201 = 0;
  return D.5201;
  <D.5200>:
  i = 0;
  goto <D.4878>;
  <D.4877>:
  D.5202 = src->data[i];
  D.5203 = src1->data[i];
  if (D.5202 != D.5203) goto <D.5204>; else goto <D.5205>;
  <D.5204>:
  D.5201 = 0;
  return D.5201;
  <D.5205>:
  i = i + 1;
  <D.4878>:
  i.21 = (unsigned int) i;
  D.5197 = src->size;
  D.5207 = D.5197 / 32;
  if (i.21 < D.5207) goto <D.4877>; else goto <D.4879>;
  <D.4879>:
  D.5201 = 1;
  return D.5201;
}


mono_bitset_foreach (struct MonoBitSet * set, void (*MonoBitSetFunc) (guint, void *) func, void * data)
{
  unsigned int D.5209;
  unsigned int D.5212;
  unsigned int D.5213;
  unsigned int i.22;
  unsigned int D.5217;
  unsigned int j.23;
  unsigned int D.5219;
  unsigned int i.24;
  unsigned int D.5221;
  unsigned int D.5222;
  int i;
  int j;

  i = 0;
  goto <D.4891>;
  <D.4890>:
  D.5209 = set->data[i];
  if (D.5209 != 0) goto <D.5210>; else goto <D.5211>;
  <D.5210>:
  j = 0;
  goto <D.4888>;
  <D.4887>:
  D.5209 = set->data[i];
  D.5212 = 1 << j;
  D.5213 = D.5209 & D.5212;
  if (D.5213 != 0) goto <D.5214>; else goto <D.5215>;
  <D.5214>:
  i.22 = (unsigned int) i;
  D.5217 = i.22 * 32;
  j.23 = (unsigned int) j;
  D.5219 = D.5217 + j.23;
  func (D.5219, data);
  <D.5215>:
  j = j + 1;
  <D.4888>:
  j.23 = (unsigned int) j;
  if (j.23 <= 31) goto <D.4887>; else goto <D.4889>;
  <D.4889>:
  <D.5211>:
  i = i + 1;
  <D.4891>:
  i.24 = (unsigned int) i;
  D.5221 = set->size;
  D.5222 = D.5221 / 32;
  if (i.24 < D.5222) goto <D.4890>; else goto <D.4892>;
  <D.4892>:
}