mono_bitset_alloc_size (guint32 max_size, guint32 flags)
{
  long unsigned int D.5219;
  long unsigned int D.5220;
  long unsigned int D.5221;
  guint32 D.5222;
  long unsigned int D.5223;
  long unsigned int D.5224;
  unsigned int D.5225;
  guint32 real_size;

  D.5219 = (long unsigned int) max_size;
  D.5220 = D.5219 + 63;
  D.5221 = D.5220 / 64;
  real_size = (guint32) D.5221;
  D.5223 = (long unsigned int) real_size;
  D.5224 = D.5223 + 2;
  D.5225 = (unsigned int) D.5224;
  D.5222 = D.5225 * 8;
  return D.5222;
}


mono_bitset_new (guint32 max_size, guint32 flags)
{
  long unsigned int D.5227;
  long unsigned int D.5228;
  long unsigned int D.5229;
  long unsigned int D.5230;
  long unsigned int D.5231;
  long unsigned int D.5232;
  long unsigned int D.5233;
  long unsigned int D.5234;
  struct MonoBitSet * D.5235;
  guint32 real_size;
  struct MonoBitSet * result;

  D.5227 = (long unsigned int) max_size;
  D.5228 = D.5227 + 63;
  D.5229 = D.5228 / 64;
  real_size = (guint32) D.5229;
  D.5230 = (long unsigned int) real_size;
  D.5231 = D.5230 + 2;
  D.5232 = D.5231 * 8;
  result = monoeg_malloc0 (D.5232);
  D.5230 = (long unsigned int) real_size;
  D.5233 = D.5230 * 64;
  result->size = D.5233;
  D.5234 = (long unsigned int) flags;
  result->flags = D.5234;
  D.5235 = result;
  return D.5235;
}


mono_bitset_mem_new (void * mem, guint32 max_size, guint32 flags)
{
  long unsigned int D.5237;
  long unsigned int D.5238;
  long unsigned int D.5239;
  long unsigned int D.5240;
  long unsigned int D.5241;
  unsigned int D.5242;
  long unsigned int D.5243;
  struct MonoBitSet * D.5244;
  guint32 real_size;
  struct MonoBitSet * result;

  D.5237 = (long unsigned int) max_size;
  D.5238 = D.5237 + 63;
  D.5239 = D.5238 / 64;
  real_size = (guint32) D.5239;
  result = mem;
  D.5240 = (long unsigned int) real_size;
  D.5241 = D.5240 * 64;
  result->size = D.5241;
  D.5242 = flags | 1;
  D.5243 = (long unsigned int) D.5242;
  result->flags = D.5243;
  D.5244 = result;
  return D.5244;
}


mono_bitset_free (struct MonoBitSet * set)
{
  long unsigned int D.5246;
  long unsigned int D.5247;

  D.5246 = set->flags;
  D.5247 = D.5246 & 1;
  if (D.5247 == 0) goto <D.5248>; else goto <D.5249>;
  <D.5248>:
  monoeg_g_free (set);
  <D.5249>:
}


mono_bitset_set (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5250;
  int pos.0;
  long unsigned int D.5252;
  long unsigned int D.5253;
  _Bool D.5254;
  long int D.5255;
  long int D.5256;
  long unsigned int D.5259;
  long unsigned int D.5260;
  long unsigned int D.5261;
  int j;
  int bit;

  D.5250 = pos / 64;
  j = (int) D.5250;
  pos.0 = (int) pos;
  bit = pos.0 & 63;
  D.5252 = (long unsigned int) pos;
  D.5253 = set->size;
  D.5254 = D.5252 >= D.5253;
  D.5255 = (long int) D.5254;
  D.5256 = __builtin_expect (D.5255, 0);
  if (D.5256 != 0) goto <D.5257>; else goto <D.5258>;
  <D.5257>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 90, "pos < set->size");
  <D.5258>:
  D.5259 = set->data[j];
  D.5260 = 1 << bit;
  D.5261 = D.5259 | D.5260;
  set->data[j] = D.5261;
}


mono_bitset_test (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5262;
  int pos.1;
  long unsigned int D.5264;
  long unsigned int D.5265;
  int D.5268;
  long unsigned int D.5269;
  long unsigned int D.5270;
  long unsigned int D.5271;
  _Bool D.5272;
  int j;
  int bit;

  D.5262 = pos / 64;
  j = (int) D.5262;
  pos.1 = (int) pos;
  bit = pos.1 & 63;
  D.5264 = (long unsigned int) pos;
  D.5265 = set->size;
  if (D.5264 >= D.5265) goto <D.5266>; else goto <D.5267>;
  <D.5266>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 108, "pos < set->size");
  D.5268 = 0;
  return D.5268;
  <D.5267>:
  D.5269 = set->data[j];
  D.5270 = D.5269 >> bit;
  D.5271 = D.5270 & 1;
  D.5272 = D.5271 != 0;
  D.5268 = (int) D.5272;
  return D.5268;
}


mono_bitset_test_bulk (const struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5274;
  long unsigned int D.5275;
  long unsigned int D.5276;
  gsize D.5279;
  int j;

  D.5274 = pos / 64;
  j = (int) D.5274;
  D.5275 = (long unsigned int) pos;
  D.5276 = set->size;
  if (D.5275 >= D.5276) goto <D.5277>; else goto <D.5278>;
  <D.5277>:
  D.5279 = 0;
  return D.5279;
  <D.5278>:
  D.5279 = set->data[j];
  return D.5279;
}


mono_bitset_clear (struct MonoBitSet * set, guint32 pos)
{
  unsigned int D.5281;
  int pos.2;
  long unsigned int D.5283;
  long unsigned int D.5284;
  _Bool D.5285;
  long int D.5286;
  long int D.5287;
  long unsigned int D.5290;
  long unsigned int D.5291;
  long unsigned int D.5292;
  long unsigned int D.5293;
  int j;
  int bit;

  D.5281 = pos / 64;
  j = (int) D.5281;
  pos.2 = (int) pos;
  bit = pos.2 & 63;
  D.5283 = (long unsigned int) pos;
  D.5284 = set->size;
  D.5285 = D.5283 >= D.5284;
  D.5286 = (long int) D.5285;
  D.5287 = __builtin_expect (D.5286, 0);
  if (D.5287 != 0) goto <D.5288>; else goto <D.5289>;
  <D.5288>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 143, "pos < set->size");
  <D.5289>:
  D.5290 = set->data[j];
  D.5291 = 1 << bit;
  D.5292 = ~D.5291;
  D.5293 = D.5290 & D.5292;
  set->data[j] = D.5293;
}


mono_bitset_clear_all (struct MonoBitSet * set)
{
  long unsigned int D.5294;
  long unsigned int D.5295;
  gsize[0:] * D.5296;

  D.5294 = set->size;
  D.5295 = D.5294 / 8;
  D.5296 = &set->data;
  memset (D.5296, 0, D.5295);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5299;
  int D.5304;
  void * D.5306;
  long unsigned int D.5307;

  D.5299 = __builtin_constant_p (__len);
  if (D.5299 != 0) goto <D.5300>; else goto <D.5301>;
  <D.5300>:
  if (__len == 0) goto <D.5302>; else goto <D.5303>;
  <D.5302>:
  D.5304 = __builtin_constant_p (__ch);
  if (D.5304 == 0) goto <D.5297>; else goto <D.5305>;
  <D.5305>:
  if (__ch != 0) goto <D.5297>; else goto <D.5298>;
  <D.5297>:
  __warn_memset_zero_len ();
  D.5306 = __dest;
  return D.5306;
  <D.5298>:
  <D.5303>:
  <D.5301>:
  D.5307 = __builtin_object_size (__dest, 0);
  D.5306 = __builtin___memset_chk (__dest, __ch, __len, D.5307);
  return D.5306;
}


mono_bitset_set_all (struct MonoBitSet * set)
{
  long unsigned int D.5309;
  long unsigned int D.5310;
  gsize[0:] * D.5311;

  D.5309 = set->size;
  D.5310 = D.5309 / 8;
  D.5311 = &set->data;
  memset (D.5311, -1, D.5310);
}


mono_bitset_invert (struct MonoBitSet * set)
{
  long unsigned int D.5312;
  long unsigned int D.5313;
  long unsigned int D.5314;
  long unsigned int D.5315;
  long unsigned int D.5316;
  int i;

  i = 0;
  goto <D.5072>;
  <D.5071>:
  D.5312 = set->data[i];
  D.5313 = ~D.5312;
  set->data[i] = D.5313;
  i = i + 1;
  <D.5072>:
  D.5314 = (long unsigned int) i;
  D.5315 = set->size;
  D.5316 = D.5315 / 64;
  if (D.5314 < D.5316) goto <D.5071>; else goto <D.5073>;
  <D.5073>:
}


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

  D.5318 = set->size;
  D.5317 = (guint32) D.5318;
  return D.5317;
}


mono_bitset_count (const struct MonoBitSet * set)
{
  int D.5322;
  unsigned int D.5323;
  unsigned int D.5325;
  int D.5326;
  unsigned int D.5327;
  long unsigned int D.5328;
  long unsigned int D.5329;
  long unsigned int D.5330;
  guint32 D.5331;
  guint32 i;
  guint32 count;
  gsize d;

  count = 0;
  i = 0;
  goto <D.5084>;
  <D.5083>:
  d = set->data[i];
  if (1 != 0) goto <D.5320>; else goto <D.5321>;
  <D.5320>:
  D.5322 = __builtin_popcountl (d);
  D.5323 = (unsigned int) D.5322;
  count = D.5323 + count;
  goto <D.5324>;
  <D.5321>:
  D.5325 = (unsigned int) d;
  D.5326 = __builtin_popcount (D.5325);
  D.5327 = (unsigned int) D.5326;
  count = D.5327 + count;
  <D.5324>:
  i = i + 1;
  <D.5084>:
  D.5328 = (long unsigned int) i;
  D.5329 = set->size;
  D.5330 = D.5329 / 64;
  if (D.5328 < D.5330) goto <D.5083>; else goto <D.5085>;
  <D.5085>:
  D.5331 = count;
  return D.5331;
}


mono_bitset_find_start (const struct MonoBitSet * set)
{
  long unsigned int D.5333;
  int D.5336;
  int D.5337;
  unsigned int D.5338;
  long unsigned int D.5339;
  unsigned int D.5340;
  unsigned int D.5341;
  unsigned int D.5342;
  long unsigned int D.5343;
  long unsigned int D.5344;
  int i;

  i = 0;
  goto <D.5116>;
  <D.5115>:
  D.5333 = set->data[i];
  if (D.5333 != 0) goto <D.5334>; else goto <D.5335>;
  <D.5334>:
  D.5333 = set->data[i];
  D.5337 = my_g_bit_nth_lsf_nomask (D.5333);
  D.5338 = (unsigned int) D.5337;
  D.5339 = (long unsigned int) i;
  D.5340 = (unsigned int) D.5339;
  D.5341 = D.5340 * 64;
  D.5342 = D.5338 + D.5341;
  D.5336 = (int) D.5342;
  return D.5336;
  <D.5335>:
  i = i + 1;
  <D.5116>:
  D.5339 = (long unsigned int) i;
  D.5343 = set->size;
  D.5344 = D.5343 / 64;
  if (D.5339 < D.5344) goto <D.5115>; else goto <D.5117>;
  <D.5117>:
  D.5336 = -1;
  return D.5336;
}


my_g_bit_nth_lsf_nomask (gsize mask)
{
  gint D.5346;
  guint64 r;

  __asm__("bsfq %1,%0
	" : "=r" r : "rm" mask);
  D.5346 = (gint) r;
  return D.5346;
}


mono_bitset_find_first (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5351;
  long unsigned int D.5352;
  long unsigned int D.5353;
  _Bool D.5354;
  long int D.5355;
  long int D.5356;
  long unsigned int D.5359;
  int D.5364;
  long unsigned int D.5365;
  unsigned int D.5366;
  unsigned int D.5367;
  unsigned int result.3;
  unsigned int D.5369;
  long unsigned int D.5370;
  int D.5373;
  unsigned int D.5374;
  long unsigned int D.5375;
  unsigned int D.5376;
  unsigned int D.5377;
  unsigned int D.5378;
  long unsigned int D.5379;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  j = 0;
  bit = -1;
  goto <D.5350>;
  <D.5349>:
  D.5351 = (long unsigned int) pos;
  D.5352 = D.5351 / 64;
  j = (int) D.5352;
  bit = pos & 63;
  D.5351 = (long unsigned int) pos;
  D.5353 = set->size;
  D.5354 = D.5351 >= D.5353;
  D.5355 = (long int) D.5354;
  D.5356 = __builtin_expect (D.5355, 0);
  if (D.5356 != 0) goto <D.5357>; else goto <D.5358>;
  <D.5357>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 424, "pos < set->size");
  <D.5358>:
  <D.5350>:
  D.5359 = set->data[j];
  if (D.5359 != 0) goto <D.5360>; else goto <D.5361>;
  <D.5360>:
  D.5359 = set->data[j];
  result = my_g_bit_nth_lsf (D.5359, bit);
  if (result != -1) goto <D.5362>; else goto <D.5363>;
  <D.5362>:
  D.5365 = (long unsigned int) j;
  D.5366 = (unsigned int) D.5365;
  D.5367 = D.5366 * 64;
  result.3 = (unsigned int) result;
  D.5369 = D.5367 + result.3;
  D.5364 = (int) D.5369;
  return D.5364;
  <D.5363>:
  <D.5361>:
  j = j + 1;
  i = j;
  goto <D.5127>;
  <D.5126>:
  D.5370 = set->data[i];
  if (D.5370 != 0) goto <D.5371>; else goto <D.5372>;
  <D.5371>:
  D.5370 = set->data[i];
  D.5373 = my_g_bit_nth_lsf (D.5370, -1);
  D.5374 = (unsigned int) D.5373;
  D.5375 = (long unsigned int) i;
  D.5376 = (unsigned int) D.5375;
  D.5377 = D.5376 * 64;
  D.5378 = D.5374 + D.5377;
  D.5364 = (int) D.5378;
  return D.5364;
  <D.5372>:
  i = i + 1;
  <D.5127>:
  D.5375 = (long unsigned int) i;
  D.5353 = set->size;
  D.5379 = D.5353 / 64;
  if (D.5375 < D.5379) goto <D.5126>; else goto <D.5128>;
  <D.5128>:
  D.5364 = -1;
  return D.5364;
}


my_g_bit_nth_lsf (gsize mask, gint nth_bit)
{
  _Bool D.5381;
  _Bool D.5382;
  _Bool D.5383;
  gint D.5386;
  unsigned int D.5387;
  unsigned int nth_bit.4;
  unsigned int D.5389;

  nth_bit = nth_bit + 1;
  mask = mask >> nth_bit;
  D.5381 = mask == 0;
  D.5382 = nth_bit == 64;
  D.5383 = D.5381 | D.5382;
  if (D.5383 != 0) goto <D.5384>; else goto <D.5385>;
  <D.5384>:
  D.5386 = -1;
  return D.5386;
  <D.5385>:
  {
    guint64 r;

    __asm__("bsfq %1,%0
	" : "=r" r : "rm" mask);
    D.5387 = (unsigned int) r;
    nth_bit.4 = (unsigned int) nth_bit;
    D.5389 = D.5387 + nth_bit.4;
    D.5386 = (gint) D.5389;
    return D.5386;
  }
}


mono_bitset_find_last (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5393;
  unsigned int D.5394;
  unsigned int D.5395;
  long unsigned int D.5396;
  long unsigned int D.5397;
  int D.5400;
  long unsigned int D.5401;
  long unsigned int D.5406;
  unsigned int D.5407;
  unsigned int D.5408;
  unsigned int result.5;
  unsigned int D.5410;
  long unsigned int D.5411;
  int D.5414;
  unsigned int D.5415;
  long unsigned int D.5416;
  unsigned int D.5417;
  unsigned int D.5418;
  unsigned int D.5419;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  D.5393 = set->size;
  D.5394 = (unsigned int) D.5393;
  D.5395 = D.5394 + 4294967295;
  pos = (gint) D.5395;
  <D.5392>:
  D.5396 = (long unsigned int) pos;
  D.5397 = D.5396 / 64;
  j = (int) D.5397;
  bit = pos & 63;
  D.5396 = (long unsigned int) pos;
  D.5393 = set->size;
  if (D.5396 >= D.5393) goto <D.5398>; else goto <D.5399>;
  <D.5398>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 458, "pos < set->size");
  D.5400 = -1;
  return D.5400;
  <D.5399>:
  D.5401 = set->data[j];
  if (D.5401 != 0) goto <D.5402>; else goto <D.5403>;
  <D.5402>:
  D.5401 = set->data[j];
  result = my_g_bit_nth_msf (D.5401, bit);
  if (result != -1) goto <D.5404>; else goto <D.5405>;
  <D.5404>:
  D.5406 = (long unsigned int) j;
  D.5407 = (unsigned int) D.5406;
  D.5408 = D.5407 * 64;
  result.5 = (unsigned int) result;
  D.5410 = D.5408 + result.5;
  D.5400 = (int) D.5410;
  return D.5400;
  <D.5405>:
  <D.5403>:
  j = j + -1;
  i = j;
  goto <D.5138>;
  <D.5137>:
  D.5411 = set->data[i];
  if (D.5411 != 0) goto <D.5412>; else goto <D.5413>;
  <D.5412>:
  D.5411 = set->data[i];
  D.5414 = my_g_bit_nth_msf (D.5411, 64);
  D.5415 = (unsigned int) D.5414;
  D.5416 = (long unsigned int) i;
  D.5417 = (unsigned int) D.5416;
  D.5418 = D.5417 * 64;
  D.5419 = D.5415 + D.5418;
  D.5400 = (int) D.5419;
  return D.5400;
  <D.5413>:
  i = i + -1;
  <D.5138>:
  if (i >= 0) goto <D.5137>; else goto <D.5139>;
  <D.5139>:
  D.5400 = -1;
  return D.5400;
}


my_g_bit_nth_msf (gsize mask, gint nth_bit)
{
  int D.5423;
  unsigned int nth_bit.6;
  unsigned int D.5425;
  int D.5426;
  long unsigned int D.5428;
  signed long mask.7;
  unsigned int i.8;
  unsigned int D.5435;
  unsigned int D.5436;
  int i;

  if (nth_bit == 0) goto <D.5421>; else goto <D.5422>;
  <D.5421>:
  D.5423 = -1;
  return D.5423;
  <D.5422>:
  nth_bit.6 = (unsigned int) nth_bit;
  D.5425 = 64 - nth_bit.6;
  D.5426 = (int) D.5425;
  mask = mask << D.5426;
  i = 64;
  goto <D.5101>;
  <D.5100>:
  mask = mask << 8;
  i = i + -8;
  <D.5101>:
  if (i > 0) goto <D.5427>; else goto <D.5102>;
  <D.5427>:
  D.5428 = mask >> 56;
  if (D.5428 == 0) goto <D.5100>; else goto <D.5102>;
  <D.5102>:
  if (mask == 0) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  D.5423 = -1;
  return D.5423;
  <D.5430>:
  <D.5103>:
  i = i + -1;
  mask.7 = (signed long) mask;
  if (mask.7 < 0) goto <D.5432>; else goto <D.5433>;
  <D.5432>:
  i.8 = (unsigned int) i;
  nth_bit.6 = (unsigned int) nth_bit;
  D.5435 = i.8 + nth_bit.6;
  D.5436 = D.5435 + 4294967232;
  D.5423 = (int) D.5436;
  return D.5423;
  <D.5433>:
  mask = mask << 1;
  if (mask != 0) goto <D.5103>; else goto <D.5104>;
  <D.5104>:
  D.5423 = -1;
  return D.5423;
}


mono_bitset_find_first_unset (const struct MonoBitSet * set, gint pos)
{
  long unsigned int D.5441;
  long unsigned int D.5442;
  long unsigned int D.5443;
  int D.5446;
  long unsigned int D.5447;
  long unsigned int D.5452;
  unsigned int D.5453;
  unsigned int D.5454;
  unsigned int result.9;
  unsigned int D.5456;
  long unsigned int D.5457;
  int D.5460;
  unsigned int D.5461;
  long unsigned int D.5462;
  unsigned int D.5463;
  unsigned int D.5464;
  unsigned int D.5465;
  long unsigned int D.5466;
  int j;
  int bit;
  int result;
  int i;

  if (pos < 0) goto <D.5438>; else goto <D.5439>;
  <D.5438>:
  j = 0;
  bit = -1;
  goto <D.5440>;
  <D.5439>:
  D.5441 = (long unsigned int) pos;
  D.5442 = D.5441 / 64;
  j = (int) D.5442;
  bit = pos & 63;
  D.5441 = (long unsigned int) pos;
  D.5443 = set->size;
  if (D.5441 >= D.5443) goto <D.5444>; else goto <D.5445>;
  <D.5444>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "monobitset.c", 492, "pos < set->size");
  D.5446 = -1;
  return D.5446;
  <D.5445>:
  <D.5440>:
  D.5447 = set->data[j];
  if (D.5447 != 18446744073709551615) goto <D.5448>; else goto <D.5449>;
  <D.5448>:
  D.5447 = set->data[j];
  result = find_first_unset (D.5447, bit);
  if (result != -1) goto <D.5450>; else goto <D.5451>;
  <D.5450>:
  D.5452 = (long unsigned int) j;
  D.5453 = (unsigned int) D.5452;
  D.5454 = D.5453 * 64;
  result.9 = (unsigned int) result;
  D.5456 = D.5454 + result.9;
  D.5446 = (int) D.5456;
  return D.5446;
  <D.5451>:
  <D.5449>:
  j = j + 1;
  i = j;
  goto <D.5149>;
  <D.5148>:
  D.5457 = set->data[i];
  if (D.5457 != 18446744073709551615) goto <D.5458>; else goto <D.5459>;
  <D.5458>:
  D.5457 = set->data[i];
  D.5460 = find_first_unset (D.5457, -1);
  D.5461 = (unsigned int) D.5460;
  D.5462 = (long unsigned int) i;
  D.5463 = (unsigned int) D.5462;
  D.5464 = D.5463 * 64;
  D.5465 = D.5461 + D.5464;
  D.5446 = (int) D.5465;
  return D.5446;
  <D.5459>:
  i = i + 1;
  <D.5149>:
  D.5462 = (long unsigned int) i;
  D.5443 = set->size;
  D.5466 = D.5443 / 64;
  if (D.5462 < D.5466) goto <D.5148>; else goto <D.5150>;
  <D.5150>:
  D.5446 = -1;
  return D.5446;
}


find_first_unset (gsize mask, gint nth_bit)
{
  long unsigned int D.5468;
  long unsigned int D.5469;
  int D.5474;
  unsigned int nth_bit.10;

  <D.5109>:
  nth_bit = nth_bit + 1;
  D.5468 = mask >> nth_bit;
  D.5469 = D.5468 & 1;
  if (D.5469 == 0) goto <D.5470>; else goto <D.5471>;
  <D.5470>:
  if (nth_bit == 64) goto <D.5472>; else goto <D.5473>;
  <D.5472>:
  D.5474 = -1;
  return D.5474;
  <D.5473>:
  D.5474 = nth_bit;
  return D.5474;
  <D.5471>:
  nth_bit.10 = (unsigned int) nth_bit;
  if (nth_bit.10 <= 63) goto <D.5109>; else goto <D.5110>;
  <D.5110>:
  D.5474 = -1;
  return D.5474;
}


mono_bitset_clone (const struct MonoBitSet * set, guint32 new_size)
{
  long unsigned int D.5479;
  long unsigned int D.5480;
  unsigned int D.5481;
  long unsigned int D.5482;
  long unsigned int D.5483;
  long unsigned int D.5484;
  const gsize[0:] * D.5485;
  gsize[0:] * D.5486;
  struct MonoBitSet * D.5487;
  struct MonoBitSet * result;

  if (new_size == 0) goto <D.5477>; else goto <D.5478>;
  <D.5477>:
  D.5479 = set->size;
  new_size = (guint32) D.5479;
  <D.5478>:
  D.5480 = set->flags;
  D.5481 = (unsigned int) D.5480;
  result = mono_bitset_new (new_size, D.5481);
  D.5482 = result->flags;
  D.5483 = D.5482 & 18446744073709551614;
  result->flags = D.5483;
  D.5479 = set->size;
  D.5484 = D.5479 / 8;
  D.5485 = &set->data;
  D.5486 = &result->data;
  memcpy (D.5486, D.5485, D.5484);
  D.5487 = result;
  return D.5487;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5489;
  long unsigned int D.5490;

  D.5490 = __builtin_object_size (__dest, 0);
  D.5489 = __builtin___memcpy_chk (__dest, __src, __len, D.5490);
  return D.5489;
}


mono_bitset_copyto (const struct MonoBitSet * src, struct MonoBitSet * dest)
{
  long unsigned int D.5492;
  long unsigned int D.5493;
  _Bool D.5494;
  long int D.5495;
  long int D.5496;
  long unsigned int D.5499;
  const gsize[0:] * D.5500;
  gsize[0:] * D.5501;

  D.5492 = dest->size;
  D.5493 = src->size;
  D.5494 = D.5492 > D.5493;
  D.5495 = (long int) D.5494;
  D.5496 = __builtin_expect (D.5495, 0);
  if (D.5496 != 0) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 539, "dest->size <= src->size");
  <D.5498>:
  D.5492 = dest->size;
  D.5499 = D.5492 / 8;
  D.5500 = &src->data;
  D.5501 = &dest->data;
  memcpy (D.5501, D.5500, D.5499);
}


mono_bitset_union (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5502;
  long unsigned int D.5503;
  _Bool D.5504;
  long int D.5505;
  long int D.5506;
  long unsigned int D.5509;
  long unsigned int D.5510;
  long unsigned int D.5511;
  long unsigned int D.5512;
  int i;
  int size;

  D.5502 = src->size;
  D.5503 = dest->size;
  D.5504 = D.5502 > D.5503;
  D.5505 = (long int) D.5504;
  D.5506 = __builtin_expect (D.5505, 0);
  if (D.5506 != 0) goto <D.5507>; else goto <D.5508>;
  <D.5507>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 555, "src->size <= dest->size");
  <D.5508>:
  D.5503 = dest->size;
  D.5509 = D.5503 / 64;
  size = (int) D.5509;
  i = 0;
  goto <D.5167>;
  <D.5166>:
  D.5510 = dest->data[i];
  D.5511 = src->data[i];
  D.5512 = D.5510 | D.5511;
  dest->data[i] = D.5512;
  i = i + 1;
  <D.5167>:
  if (i < size) goto <D.5166>; else goto <D.5168>;
  <D.5168>:
}


mono_bitset_intersection (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5513;
  long unsigned int D.5514;
  _Bool D.5515;
  long int D.5516;
  long int D.5517;
  long unsigned int D.5520;
  long unsigned int D.5521;
  long unsigned int D.5522;
  long unsigned int D.5523;
  int i;
  int size;

  D.5513 = src->size;
  D.5514 = dest->size;
  D.5515 = D.5513 > D.5514;
  D.5516 = (long int) D.5515;
  D.5517 = __builtin_expect (D.5516, 0);
  if (D.5517 != 0) goto <D.5518>; else goto <D.5519>;
  <D.5518>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 573, "src->size <= dest->size");
  <D.5519>:
  D.5514 = dest->size;
  D.5520 = D.5514 / 64;
  size = (int) D.5520;
  i = 0;
  goto <D.5176>;
  <D.5175>:
  D.5521 = dest->data[i];
  D.5522 = src->data[i];
  D.5523 = D.5521 & D.5522;
  dest->data[i] = D.5523;
  i = i + 1;
  <D.5176>:
  if (i < size) goto <D.5175>; else goto <D.5177>;
  <D.5177>:
}


mono_bitset_intersection_2 (struct MonoBitSet * dest, const struct MonoBitSet * src1, const struct MonoBitSet * src2)
{
  long unsigned int D.5524;
  long unsigned int D.5525;
  _Bool D.5526;
  long int D.5527;
  long int D.5528;
  long unsigned int D.5531;
  _Bool D.5532;
  long int D.5533;
  long int D.5534;
  long unsigned int D.5537;
  long unsigned int D.5538;
  long unsigned int D.5539;
  long unsigned int D.5540;
  int i;
  int size;

  D.5524 = src1->size;
  D.5525 = dest->size;
  D.5526 = D.5524 > D.5525;
  D.5527 = (long int) D.5526;
  D.5528 = __builtin_expect (D.5527, 0);
  if (D.5528 != 0) goto <D.5529>; else goto <D.5530>;
  <D.5529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 592, "src1->size <= dest->size");
  <D.5530>:
  D.5531 = src2->size;
  D.5525 = dest->size;
  D.5532 = D.5531 > D.5525;
  D.5533 = (long int) D.5532;
  D.5534 = __builtin_expect (D.5533, 0);
  if (D.5534 != 0) goto <D.5535>; else goto <D.5536>;
  <D.5535>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 593, "src2->size <= dest->size");
  <D.5536>:
  D.5525 = dest->size;
  D.5537 = D.5525 / 64;
  size = (int) D.5537;
  i = 0;
  goto <D.5186>;
  <D.5185>:
  D.5538 = src1->data[i];
  D.5539 = src2->data[i];
  D.5540 = D.5538 & D.5539;
  dest->data[i] = D.5540;
  i = i + 1;
  <D.5186>:
  if (i < size) goto <D.5185>; else goto <D.5187>;
  <D.5187>:
}


mono_bitset_sub (struct MonoBitSet * dest, const struct MonoBitSet * src)
{
  long unsigned int D.5541;
  long unsigned int D.5542;
  _Bool D.5543;
  long int D.5544;
  long int D.5545;
  long unsigned int D.5548;
  long unsigned int D.5549;
  long unsigned int D.5550;
  long unsigned int D.5551;
  long unsigned int D.5552;
  int i;
  int size;

  D.5541 = src->size;
  D.5542 = dest->size;
  D.5543 = D.5541 > D.5542;
  D.5544 = (long int) D.5543;
  D.5545 = __builtin_expect (D.5544, 0);
  if (D.5545 != 0) goto <D.5546>; else goto <D.5547>;
  <D.5546>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "monobitset.c", 611, "src->size <= dest->size");
  <D.5547>:
  D.5541 = src->size;
  D.5548 = D.5541 / 64;
  size = (int) D.5548;
  i = 0;
  goto <D.5195>;
  <D.5194>:
  D.5549 = dest->data[i];
  D.5550 = src->data[i];
  D.5551 = ~D.5550;
  D.5552 = D.5549 & D.5551;
  dest->data[i] = D.5552;
  i = i + 1;
  <D.5195>:
  if (i < size) goto <D.5194>; else goto <D.5196>;
  <D.5196>:
}


mono_bitset_equal (const struct MonoBitSet * src, const struct MonoBitSet * src1)
{
  long unsigned int D.5553;
  long unsigned int D.5554;
  gboolean D.5557;
  long unsigned int D.5558;
  long unsigned int D.5559;
  long unsigned int D.5562;
  long unsigned int D.5563;
  int i;

  D.5553 = src->size;
  D.5554 = src1->size;
  if (D.5553 != D.5554) goto <D.5555>; else goto <D.5556>;
  <D.5555>:
  D.5557 = 0;
  return D.5557;
  <D.5556>:
  i = 0;
  goto <D.5203>;
  <D.5202>:
  D.5558 = src->data[i];
  D.5559 = src1->data[i];
  if (D.5558 != D.5559) goto <D.5560>; else goto <D.5561>;
  <D.5560>:
  D.5557 = 0;
  return D.5557;
  <D.5561>:
  i = i + 1;
  <D.5203>:
  D.5562 = (long unsigned int) i;
  D.5553 = src->size;
  D.5563 = D.5553 / 64;
  if (D.5562 < D.5563) goto <D.5202>; else goto <D.5204>;
  <D.5204>:
  D.5557 = 1;
  return D.5557;
}


mono_bitset_foreach (struct MonoBitSet * set, void (*MonoBitSetFunc) (guint, void *) func, void * data)
{
  long unsigned int D.5565;
  long unsigned int D.5568;
  long unsigned int D.5569;
  long unsigned int D.5572;
  unsigned int D.5573;
  unsigned int D.5574;
  unsigned int j.11;
  unsigned int D.5576;
  unsigned int j.12;
  long unsigned int D.5578;
  long unsigned int D.5579;
  int i;
  int j;

  i = 0;
  goto <D.5216>;
  <D.5215>:
  D.5565 = set->data[i];
  if (D.5565 != 0) goto <D.5566>; else goto <D.5567>;
  <D.5566>:
  j = 0;
  goto <D.5213>;
  <D.5212>:
  D.5565 = set->data[i];
  D.5568 = D.5565 >> j;
  D.5569 = D.5568 & 1;
  if (D.5569 != 0) goto <D.5570>; else goto <D.5571>;
  <D.5570>:
  D.5572 = (long unsigned int) i;
  D.5573 = (unsigned int) D.5572;
  D.5574 = D.5573 * 64;
  j.11 = (unsigned int) j;
  D.5576 = D.5574 + j.11;
  func (D.5576, data);
  <D.5571>:
  j = j + 1;
  <D.5213>:
  j.12 = (unsigned int) j;
  if (j.12 <= 63) goto <D.5212>; else goto <D.5214>;
  <D.5214>:
  <D.5567>:
  i = i + 1;
  <D.5216>:
  D.5572 = (long unsigned int) i;
  D.5578 = set->size;
  D.5579 = D.5578 / 64;
  if (D.5572 < D.5579) goto <D.5215>; else goto <D.5217>;
  <D.5217>:
}