monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.6319;
  guint D.6322;
  unsigned int i.0;
  int x.1;
  int D.6325;
  int i;

  i = 0;
  goto <D.6068>;
  <D.6067>:
  D.6319 = prime_tbl[i];
  if (D.6319 >= x) goto <D.6320>; else goto <D.6321>;
  <D.6320>:
  D.6322 = prime_tbl[i];
  return D.6322;
  <D.6321>:
  i = i + 1;
  <D.6068>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.6067>; else goto <D.6069>;
  <D.6069>:
  x.1 = (int) x;
  D.6325 = calc_prime (x.1);
  D.6322 = (guint) D.6325;
  return D.6322;
}


calc_prime (int x)
{
  int D.6327;
  int D.6328;
  int D.6331;
  int i;

  D.6327 = x & -2;
  i = D.6327 + -1;
  goto <D.6061>;
  <D.6060>:
  D.6328 = test_prime (i);
  if (D.6328 != 0) goto <D.6329>; else goto <D.6330>;
  <D.6329>:
  D.6331 = i;
  return D.6331;
  <D.6330>:
  i = i + 2;
  <D.6061>:
  if (i != 2147483647) goto <D.6060>; else goto <D.6062>;
  <D.6062>:
  D.6331 = x;
  return D.6331;
}


test_prime (int x)
{
  int D.6333;
  int D.6336;
  gboolean D.6339;
  double D.6340;
  double D.6341;
  int D.6342;
  _Bool D.6343;

  D.6333 = x & 1;
  if (D.6333 != 0) goto <D.6334>; else goto <D.6335>;
  <D.6334>:
  {
    int n;

    n = 3;
    goto <D.6054>;
    <D.6053>:
    D.6336 = x % n;
    if (D.6336 == 0) goto <D.6337>; else goto <D.6338>;
    <D.6337>:
    D.6339 = 0;
    return D.6339;
    <D.6338>:
    n = n + 2;
    <D.6054>:
    D.6340 = (double) x;
    D.6341 = sqrt (D.6340);
    D.6342 = (int) D.6341;
    if (D.6342 > n) goto <D.6053>; else goto <D.6055>;
    <D.6055>:
    D.6339 = 1;
    return D.6339;
  }
  <D.6335>:
  D.6343 = x == 2;
  D.6339 = (gboolean) D.6343;
  return D.6339;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.6349;
  int D.6350;
  int D.6351;
  long unsigned int D.6352;
  long unsigned int D.6353;
  void * D.6354;
  struct GHashTable * D.6355;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.6345>; else goto <D.6346>;
  <D.6345>:
  hash_func = monoeg_g_direct_hash;
  <D.6346>:
  if (key_equal_func == 0B) goto <D.6347>; else goto <D.6348>;
  <D.6347>:
  key_equal_func = monoeg_g_direct_equal;
  <D.6348>:
  hash = monoeg_malloc0 (56);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.6349 = monoeg_g_spaced_primes_closest (1);
  D.6350 = (int) D.6349;
  hash->table_size = D.6350;
  D.6351 = hash->table_size;
  D.6352 = (long unsigned int) D.6351;
  D.6353 = D.6352 * 8;
  D.6354 = monoeg_malloc0 (D.6353);
  hash->table = D.6354;
  D.6351 = hash->table_size;
  hash->last_rehash = D.6351;
  D.6355 = hash;
  return D.6355;
}


monoeg_g_hash_table_new_full (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func, void (*GDestroyNotify) (void *) key_destroy_func, void (*GDestroyNotify) (void *) value_destroy_func)
{
  struct GHashTable * D.6359;
  struct GHashTable * hash;

  hash = monoeg_g_hash_table_new (hash_func, key_equal_func);
  if (hash == 0B) goto <D.6357>; else goto <D.6358>;
  <D.6357>:
  D.6359 = 0B;
  return D.6359;
  <D.6358>:
  hash->key_destroy_func = key_destroy_func;
  hash->value_destroy_func = value_destroy_func;
  D.6359 = hash;
  return D.6359;
}


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.6363;
  int D.6364;
  guint (*<Te5c>) (const void *) D.6367;
  unsigned int D.6368;
  int D.6369;
  unsigned int D.6370;
  struct Slot * * D.6371;
  long unsigned int D.6372;
  long unsigned int D.6373;
  struct Slot * * D.6374;
  void * D.6375;
  int D.6376;
  void (*<Tdb0>) (void *) D.6381;
  void (*<Tdb0>) (void *) D.6384;
  void * D.6387;
  struct Slot * D.6388;
  int D.6389;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.6361>; else goto <D.6362>;
  <D.6361>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.6362>:
  equal = hash->key_equal_func;
  D.6363 = hash->in_use;
  D.6364 = hash->threshold;
  if (D.6363 >= D.6364) goto <D.6365>; else goto <D.6366>;
  <D.6365>:
  rehash (hash);
  <D.6366>:
  D.6367 = hash->hash_func;
  D.6368 = D.6367 (key);
  D.6369 = hash->table_size;
  D.6370 = (unsigned int) D.6369;
  hashcode = D.6368 % D.6370;
  D.6371 = hash->table;
  D.6372 = (long unsigned int) hashcode;
  D.6373 = D.6372 * 8;
  D.6374 = D.6371 + D.6373;
  s = *D.6374;
  goto <D.6111>;
  <D.6110>:
  D.6375 = s->key;
  D.6376 = equal (D.6375, key);
  if (D.6376 != 0) goto <D.6377>; else goto <D.6378>;
  <D.6377>:
  if (replace != 0) goto <D.6379>; else goto <D.6380>;
  <D.6379>:
  D.6381 = hash->key_destroy_func;
  if (D.6381 != 0B) goto <D.6382>; else goto <D.6383>;
  <D.6382>:
  D.6381 = hash->key_destroy_func;
  D.6375 = s->key;
  D.6381 (D.6375);
  <D.6383>:
  s->key = key;
  <D.6380>:
  D.6384 = hash->value_destroy_func;
  if (D.6384 != 0B) goto <D.6385>; else goto <D.6386>;
  <D.6385>:
  D.6384 = hash->value_destroy_func;
  D.6387 = s->value;
  D.6384 (D.6387);
  <D.6386>:
  s->value = value;
  return;
  <D.6378>:
  s = s->next;
  <D.6111>:
  if (s != 0B) goto <D.6110>; else goto <D.6112>;
  <D.6112>:
  s = monoeg_malloc (24);
  s->key = key;
  s->value = value;
  D.6371 = hash->table;
  D.6372 = (long unsigned int) hashcode;
  D.6373 = D.6372 * 8;
  D.6374 = D.6371 + D.6373;
  D.6388 = *D.6374;
  s->next = D.6388;
  D.6371 = hash->table;
  D.6372 = (long unsigned int) hashcode;
  D.6373 = D.6372 * 8;
  D.6374 = D.6371 + D.6373;
  *D.6374 = s;
  D.6363 = hash->in_use;
  D.6389 = D.6363 + 1;
  hash->in_use = D.6389;
}


rehash (struct GHashTable * hash)
{
  int D.6391;
  int D.6392;
  int D.6393;
  double D.6394;
  double D.6395;
  int D.6396;
  int D.6397;
  double D.6398;
  _Bool D.6399;
  _Bool D.6400;
  int diff;

  D.6391 = hash->last_rehash;
  D.6392 = hash->in_use;
  D.6393 = D.6391 - D.6392;
  diff = ABS_EXPR <D.6393>;
  D.6394 = (double) diff;
  D.6395 = D.6394 * 7.5e-1;
  D.6396 = hash->table_size;
  D.6397 = D.6396 * 2;
  D.6398 = (double) D.6397;
  D.6399 = D.6395 > D.6398;
  D.6400 = ~D.6399;
  if (D.6400 != 0) goto <D.6401>; else goto <D.6402>;
  <D.6401>:
  return;
  <D.6402>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.6404;
  int D.6405;
  unsigned int D.6406;
  unsigned int D.6407;
  int D.6408;
  long unsigned int D.6409;
  long unsigned int D.6410;
  void * D.6411;
  long unsigned int D.6412;
  long unsigned int D.6413;
  struct Slot * * D.6414;
  guint (*<Te5c>) (const void *) D.6415;
  void * D.6416;
  unsigned int D.6417;
  unsigned int D.6418;
  struct Slot * * D.6419;
  long unsigned int D.6420;
  long unsigned int D.6421;
  struct Slot * * D.6422;
  struct Slot * D.6423;
  int current_size;
  int i;
  struct Slot * * table;

  D.6404 = hash->table_size;
  hash->last_rehash = D.6404;
  current_size = hash->table_size;
  D.6405 = hash->in_use;
  D.6406 = (unsigned int) D.6405;
  D.6407 = monoeg_g_spaced_primes_closest (D.6406);
  D.6408 = (int) D.6407;
  hash->table_size = D.6408;
  table = hash->table;
  D.6404 = hash->table_size;
  D.6409 = (long unsigned int) D.6404;
  D.6410 = D.6409 * 8;
  D.6411 = monoeg_malloc0 (D.6410);
  hash->table = D.6411;
  i = 0;
  goto <D.6095>;
  <D.6094>:
  {
    struct Slot * s;
    struct Slot * next;

    D.6412 = (long unsigned int) i;
    D.6413 = D.6412 * 8;
    D.6414 = table + D.6413;
    s = *D.6414;
    goto <D.6092>;
    <D.6091>:
    {
      guint hashcode;

      D.6415 = hash->hash_func;
      D.6416 = s->key;
      D.6417 = D.6415 (D.6416);
      D.6404 = hash->table_size;
      D.6418 = (unsigned int) D.6404;
      hashcode = D.6417 % D.6418;
      next = s->next;
      D.6419 = hash->table;
      D.6420 = (long unsigned int) hashcode;
      D.6421 = D.6420 * 8;
      D.6422 = D.6419 + D.6421;
      D.6423 = *D.6422;
      s->next = D.6423;
      D.6419 = hash->table;
      D.6420 = (long unsigned int) hashcode;
      D.6421 = D.6420 * 8;
      D.6422 = D.6419 + D.6421;
      *D.6422 = s;
    }
    s = next;
    <D.6092>:
    if (s != 0B) goto <D.6091>; else goto <D.6093>;
    <D.6093>:
  }
  i = i + 1;
  <D.6095>:
  if (i < current_size) goto <D.6094>; else goto <D.6096>;
  <D.6096>:
  monoeg_g_free (table);
}


monoeg_g_hash_table_get_keys (struct GHashTable * hash)
{
  void * key.2;
  int D.6425;
  struct GList * D.6426;
  struct GHashTableIter iter;
  struct GList * rv;
  void * key;

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6120>;
      <D.6119>:
      key.2 = key;
      rv = monoeg_g_list_prepend (rv, key.2);
      <D.6120>:
      D.6425 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.6425 != 0) goto <D.6119>; else goto <D.6121>;
      <D.6121>:
      D.6426 = monoeg_g_list_reverse (rv);
      return D.6426;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


monoeg_g_hash_table_get_values (struct GHashTable * hash)
{
  void * value.3;
  int D.6430;
  struct GList * D.6431;
  struct GHashTableIter iter;
  struct GList * rv;
  void * value;

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6129>;
      <D.6128>:
      value.3 = value;
      rv = monoeg_g_list_prepend (rv, value.3);
      <D.6129>:
      D.6430 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.6430 != 0) goto <D.6128>; else goto <D.6130>;
      <D.6130>:
      D.6431 = monoeg_g_list_reverse (rv);
      return D.6431;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.6436;
  int D.6437;

  if (hash == 0B) goto <D.6434>; else goto <D.6435>;
  <D.6434>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 301, "hash != NULL");
  D.6436 = 0;
  return D.6436;
  <D.6435>:
  D.6437 = hash->in_use;
  D.6436 = (guint) D.6437;
  return D.6436;
}


monoeg_g_hash_table_lookup (struct GHashTable * hash, const void * key)
{
  int D.6439;
  void * D.6442;
  void * orig_key;
  void * value;

  try
    {
      D.6439 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.6439 != 0) goto <D.6440>; else goto <D.6441>;
      <D.6440>:
      D.6442 = value;
      return D.6442;
      <D.6441>:
      D.6442 = 0B;
      return D.6442;
    }
  finally
    {
      orig_key = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_lookup_extended (struct GHashTable * hash, const void * key, void * * orig_key, void * * value)
{
  gboolean D.6447;
  guint (*<Te5c>) (const void *) D.6448;
  unsigned int D.6449;
  int D.6450;
  unsigned int D.6451;
  struct Slot * * D.6452;
  long unsigned int D.6453;
  long unsigned int D.6454;
  struct Slot * * D.6455;
  void * D.6456;
  int D.6457;
  void * D.6464;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.6445>; else goto <D.6446>;
  <D.6445>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.6447 = 0;
  return D.6447;
  <D.6446>:
  equal = hash->key_equal_func;
  D.6448 = hash->hash_func;
  D.6449 = D.6448 (key);
  D.6450 = hash->table_size;
  D.6451 = (unsigned int) D.6450;
  hashcode = D.6449 % D.6451;
  D.6452 = hash->table;
  D.6453 = (long unsigned int) hashcode;
  D.6454 = D.6453 * 8;
  D.6455 = D.6452 + D.6454;
  s = *D.6455;
  goto <D.6150>;
  <D.6149>:
  D.6456 = s->key;
  D.6457 = equal (D.6456, key);
  if (D.6457 != 0) goto <D.6458>; else goto <D.6459>;
  <D.6458>:
  if (orig_key != 0B) goto <D.6460>; else goto <D.6461>;
  <D.6460>:
  D.6456 = s->key;
  *orig_key = D.6456;
  <D.6461>:
  if (value != 0B) goto <D.6462>; else goto <D.6463>;
  <D.6462>:
  D.6464 = s->value;
  *value = D.6464;
  <D.6463>:
  D.6447 = 1;
  return D.6447;
  <D.6459>:
  s = s->next;
  <D.6150>:
  if (s != 0B) goto <D.6149>; else goto <D.6151>;
  <D.6151>:
  D.6447 = 0;
  return D.6447;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.6470;
  long unsigned int D.6471;
  long unsigned int D.6472;
  struct Slot * * D.6473;
  void * D.6474;
  void * D.6475;
  int D.6476;
  int i;

  if (hash == 0B) goto <D.6466>; else goto <D.6467>;
  <D.6466>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.6467>:
  if (func == 0B) goto <D.6468>; else goto <D.6469>;
  <D.6468>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.6469>:
  i = 0;
  goto <D.6163>;
  <D.6162>:
  {
    struct Slot * s;

    D.6470 = hash->table;
    D.6471 = (long unsigned int) i;
    D.6472 = D.6471 * 8;
    D.6473 = D.6470 + D.6472;
    s = *D.6473;
    goto <D.6160>;
    <D.6159>:
    D.6474 = s->value;
    D.6475 = s->key;
    func (D.6475, D.6474, user_data);
    s = s->next;
    <D.6160>:
    if (s != 0B) goto <D.6159>; else goto <D.6161>;
    <D.6161>:
  }
  i = i + 1;
  <D.6163>:
  D.6476 = hash->table_size;
  if (D.6476 > i) goto <D.6162>; else goto <D.6164>;
  <D.6164>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.6480;
  struct Slot * * D.6483;
  long unsigned int D.6484;
  long unsigned int D.6485;
  struct Slot * * D.6486;
  void * D.6487;
  void * D.6488;
  int D.6489;
  int D.6492;
  int i;

  if (hash == 0B) goto <D.6478>; else goto <D.6479>;
  <D.6478>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.6480 = 0B;
  return D.6480;
  <D.6479>:
  if (predicate == 0B) goto <D.6481>; else goto <D.6482>;
  <D.6481>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.6480 = 0B;
  return D.6480;
  <D.6482>:
  i = 0;
  goto <D.6176>;
  <D.6175>:
  {
    struct Slot * s;

    D.6483 = hash->table;
    D.6484 = (long unsigned int) i;
    D.6485 = D.6484 * 8;
    D.6486 = D.6483 + D.6485;
    s = *D.6486;
    goto <D.6173>;
    <D.6172>:
    D.6487 = s->value;
    D.6488 = s->key;
    D.6489 = predicate (D.6488, D.6487, user_data);
    if (D.6489 != 0) goto <D.6490>; else goto <D.6491>;
    <D.6490>:
    D.6480 = s->value;
    return D.6480;
    <D.6491>:
    s = s->next;
    <D.6173>:
    if (s != 0B) goto <D.6172>; else goto <D.6174>;
    <D.6174>:
  }
  i = i + 1;
  <D.6176>:
  D.6492 = hash->table_size;
  if (D.6492 > i) goto <D.6175>; else goto <D.6177>;
  <D.6177>:
  D.6480 = 0B;
  return D.6480;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.6496;
  long unsigned int D.6497;
  long unsigned int D.6498;
  struct Slot * * D.6499;
  void * D.6500;
  struct Slot * D.6501;
  int D.6502;
  int i;

  if (hash == 0B) goto <D.6494>; else goto <D.6495>;
  <D.6494>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 381, "hash != NULL");
  return;
  <D.6495>:
  i = 0;
  goto <D.6187>;
  <D.6186>:
  {
    struct Slot * s;

    goto <D.6184>;
    <D.6183>:
    D.6496 = hash->table;
    D.6497 = (long unsigned int) i;
    D.6498 = D.6497 * 8;
    D.6499 = D.6496 + D.6498;
    s = *D.6499;
    D.6500 = s->key;
    monoeg_g_hash_table_remove (hash, D.6500);
    <D.6184>:
    D.6496 = hash->table;
    D.6497 = (long unsigned int) i;
    D.6498 = D.6497 * 8;
    D.6499 = D.6496 + D.6498;
    D.6501 = *D.6499;
    if (D.6501 != 0B) goto <D.6183>; else goto <D.6185>;
    <D.6185>:
  }
  i = i + 1;
  <D.6187>:
  D.6502 = hash->table_size;
  if (D.6502 > i) goto <D.6186>; else goto <D.6188>;
  <D.6188>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.6506;
  guint (*<Te5c>) (const void *) D.6507;
  unsigned int D.6508;
  int D.6509;
  unsigned int D.6510;
  struct Slot * * D.6511;
  long unsigned int D.6512;
  long unsigned int D.6513;
  struct Slot * * D.6514;
  void * D.6515;
  int D.6516;
  void (*<Tdb0>) (void *) D.6519;
  void (*<Tdb0>) (void *) D.6522;
  void * D.6525;
  struct Slot * D.6528;
  int D.6530;
  int D.6531;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6504>; else goto <D.6505>;
  <D.6504>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.6506 = 0;
  return D.6506;
  <D.6505>:
  equal = hash->key_equal_func;
  D.6507 = hash->hash_func;
  D.6508 = D.6507 (key);
  D.6509 = hash->table_size;
  D.6510 = (unsigned int) D.6509;
  hashcode = D.6508 % D.6510;
  last = 0B;
  D.6511 = hash->table;
  D.6512 = (long unsigned int) hashcode;
  D.6513 = D.6512 * 8;
  D.6514 = D.6511 + D.6513;
  s = *D.6514;
  goto <D.6198>;
  <D.6197>:
  D.6515 = s->key;
  D.6516 = equal (D.6515, key);
  if (D.6516 != 0) goto <D.6517>; else goto <D.6518>;
  <D.6517>:
  D.6519 = hash->key_destroy_func;
  if (D.6519 != 0B) goto <D.6520>; else goto <D.6521>;
  <D.6520>:
  D.6519 = hash->key_destroy_func;
  D.6515 = s->key;
  D.6519 (D.6515);
  <D.6521>:
  D.6522 = hash->value_destroy_func;
  if (D.6522 != 0B) goto <D.6523>; else goto <D.6524>;
  <D.6523>:
  D.6522 = hash->value_destroy_func;
  D.6525 = s->value;
  D.6522 (D.6525);
  <D.6524>:
  if (last == 0B) goto <D.6526>; else goto <D.6527>;
  <D.6526>:
  D.6511 = hash->table;
  D.6512 = (long unsigned int) hashcode;
  D.6513 = D.6512 * 8;
  D.6514 = D.6511 + D.6513;
  D.6528 = s->next;
  *D.6514 = D.6528;
  goto <D.6529>;
  <D.6527>:
  D.6528 = s->next;
  last->next = D.6528;
  <D.6529>:
  monoeg_g_free (s);
  D.6530 = hash->in_use;
  D.6531 = D.6530 + -1;
  hash->in_use = D.6531;
  D.6506 = 1;
  return D.6506;
  <D.6518>:
  last = s;
  s = s->next;
  <D.6198>:
  if (s != 0B) goto <D.6197>; else goto <D.6199>;
  <D.6199>:
  D.6506 = 0;
  return D.6506;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6535;
  struct Slot * * D.6538;
  long unsigned int D.6539;
  long unsigned int D.6540;
  struct Slot * * D.6541;
  void * D.6542;
  void * D.6543;
  int D.6544;
  void (*<Tdb0>) (void *) D.6547;
  void (*<Tdb0>) (void *) D.6550;
  struct Slot * D.6555;
  int D.6557;
  int D.6558;
  int D.6560;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6533>; else goto <D.6534>;
  <D.6533>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.6535 = 0;
  return D.6535;
  <D.6534>:
  if (func == 0B) goto <D.6536>; else goto <D.6537>;
  <D.6536>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.6535 = 0;
  return D.6535;
  <D.6537>:
  i = 0;
  goto <D.6214>;
  <D.6213>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6538 = hash->table;
    D.6539 = (long unsigned int) i;
    D.6540 = D.6539 * 8;
    D.6541 = D.6538 + D.6540;
    s = *D.6541;
    goto <D.6211>;
    <D.6210>:
    D.6542 = s->value;
    D.6543 = s->key;
    D.6544 = func (D.6543, D.6542, user_data);
    if (D.6544 != 0) goto <D.6545>; else goto <D.6546>;
    <D.6545>:
    {
      struct Slot * n;

      D.6547 = hash->key_destroy_func;
      if (D.6547 != 0B) goto <D.6548>; else goto <D.6549>;
      <D.6548>:
      D.6547 = hash->key_destroy_func;
      D.6543 = s->key;
      D.6547 (D.6543);
      <D.6549>:
      D.6550 = hash->value_destroy_func;
      if (D.6550 != 0B) goto <D.6551>; else goto <D.6552>;
      <D.6551>:
      D.6550 = hash->value_destroy_func;
      D.6542 = s->value;
      D.6550 (D.6542);
      <D.6552>:
      if (last == 0B) goto <D.6553>; else goto <D.6554>;
      <D.6553>:
      D.6538 = hash->table;
      D.6539 = (long unsigned int) i;
      D.6540 = D.6539 * 8;
      D.6541 = D.6538 + D.6540;
      D.6555 = s->next;
      *D.6541 = D.6555;
      n = s->next;
      goto <D.6556>;
      <D.6554>:
      D.6555 = s->next;
      last->next = D.6555;
      n = last->next;
      <D.6556>:
      monoeg_g_free (s);
      D.6557 = hash->in_use;
      D.6558 = D.6557 + -1;
      hash->in_use = D.6558;
      count = count + 1;
      s = n;
    }
    goto <D.6559>;
    <D.6546>:
    last = s;
    s = s->next;
    <D.6559>:
    <D.6211>:
    if (s != 0B) goto <D.6210>; else goto <D.6212>;
    <D.6212>:
  }
  i = i + 1;
  <D.6214>:
  D.6560 = hash->table_size;
  if (D.6560 > i) goto <D.6213>; else goto <D.6215>;
  <D.6215>:
  if (count > 0) goto <D.6561>; else goto <D.6562>;
  <D.6561>:
  rehash (hash);
  <D.6562>:
  D.6535 = (guint) count;
  return D.6535;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.6566;
  guint (*<Te5c>) (const void *) D.6567;
  unsigned int D.6568;
  int D.6569;
  unsigned int D.6570;
  struct Slot * * D.6571;
  long unsigned int D.6572;
  long unsigned int D.6573;
  struct Slot * * D.6574;
  void * D.6575;
  int D.6576;
  struct Slot * D.6581;
  int D.6583;
  int D.6584;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6564>; else goto <D.6565>;
  <D.6564>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.6566 = 0;
  return D.6566;
  <D.6565>:
  equal = hash->key_equal_func;
  D.6567 = hash->hash_func;
  D.6568 = D.6567 (key);
  D.6569 = hash->table_size;
  D.6570 = (unsigned int) D.6569;
  hashcode = D.6568 % D.6570;
  last = 0B;
  D.6571 = hash->table;
  D.6572 = (long unsigned int) hashcode;
  D.6573 = D.6572 * 8;
  D.6574 = D.6571 + D.6573;
  s = *D.6574;
  goto <D.6225>;
  <D.6224>:
  D.6575 = s->key;
  D.6576 = equal (D.6575, key);
  if (D.6576 != 0) goto <D.6577>; else goto <D.6578>;
  <D.6577>:
  if (last == 0B) goto <D.6579>; else goto <D.6580>;
  <D.6579>:
  D.6571 = hash->table;
  D.6572 = (long unsigned int) hashcode;
  D.6573 = D.6572 * 8;
  D.6574 = D.6571 + D.6573;
  D.6581 = s->next;
  *D.6574 = D.6581;
  goto <D.6582>;
  <D.6580>:
  D.6581 = s->next;
  last->next = D.6581;
  <D.6582>:
  monoeg_g_free (s);
  D.6583 = hash->in_use;
  D.6584 = D.6583 + -1;
  hash->in_use = D.6584;
  D.6566 = 1;
  return D.6566;
  <D.6578>:
  last = s;
  s = s->next;
  <D.6225>:
  if (s != 0B) goto <D.6224>; else goto <D.6226>;
  <D.6226>:
  D.6566 = 0;
  return D.6566;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6588;
  struct Slot * * D.6591;
  long unsigned int D.6592;
  long unsigned int D.6593;
  struct Slot * * D.6594;
  void * D.6595;
  void * D.6596;
  int D.6597;
  struct Slot * D.6602;
  int D.6604;
  int D.6605;
  int D.6607;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6586>; else goto <D.6587>;
  <D.6586>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.6588 = 0;
  return D.6588;
  <D.6587>:
  if (func == 0B) goto <D.6589>; else goto <D.6590>;
  <D.6589>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.6588 = 0;
  return D.6588;
  <D.6590>:
  i = 0;
  goto <D.6241>;
  <D.6240>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6591 = hash->table;
    D.6592 = (long unsigned int) i;
    D.6593 = D.6592 * 8;
    D.6594 = D.6591 + D.6593;
    s = *D.6594;
    goto <D.6238>;
    <D.6237>:
    D.6595 = s->value;
    D.6596 = s->key;
    D.6597 = func (D.6596, D.6595, user_data);
    if (D.6597 != 0) goto <D.6598>; else goto <D.6599>;
    <D.6598>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.6600>; else goto <D.6601>;
      <D.6600>:
      D.6591 = hash->table;
      D.6592 = (long unsigned int) i;
      D.6593 = D.6592 * 8;
      D.6594 = D.6591 + D.6593;
      D.6602 = s->next;
      *D.6594 = D.6602;
      n = s->next;
      goto <D.6603>;
      <D.6601>:
      D.6602 = s->next;
      last->next = D.6602;
      n = last->next;
      <D.6603>:
      monoeg_g_free (s);
      D.6604 = hash->in_use;
      D.6605 = D.6604 + -1;
      hash->in_use = D.6605;
      count = count + 1;
      s = n;
    }
    goto <D.6606>;
    <D.6599>:
    last = s;
    s = s->next;
    <D.6606>:
    <D.6238>:
    if (s != 0B) goto <D.6237>; else goto <D.6239>;
    <D.6239>:
  }
  i = i + 1;
  <D.6241>:
  D.6607 = hash->table_size;
  if (D.6607 > i) goto <D.6240>; else goto <D.6242>;
  <D.6242>:
  if (count > 0) goto <D.6608>; else goto <D.6609>;
  <D.6608>:
  rehash (hash);
  <D.6609>:
  D.6588 = (guint) count;
  return D.6588;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.6613;
  long unsigned int D.6614;
  long unsigned int D.6615;
  struct Slot * * D.6616;
  void (*<Tdb0>) (void *) D.6617;
  void * D.6620;
  void (*<Tdb0>) (void *) D.6621;
  void * D.6624;
  int D.6625;
  int i;

  if (hash == 0B) goto <D.6611>; else goto <D.6612>;
  <D.6611>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 549, "hash != NULL");
  return;
  <D.6612>:
  i = 0;
  goto <D.6253>;
  <D.6252>:
  {
    struct Slot * s;
    struct Slot * next;

    D.6613 = hash->table;
    D.6614 = (long unsigned int) i;
    D.6615 = D.6614 * 8;
    D.6616 = D.6613 + D.6615;
    s = *D.6616;
    goto <D.6250>;
    <D.6249>:
    next = s->next;
    D.6617 = hash->key_destroy_func;
    if (D.6617 != 0B) goto <D.6618>; else goto <D.6619>;
    <D.6618>:
    D.6617 = hash->key_destroy_func;
    D.6620 = s->key;
    D.6617 (D.6620);
    <D.6619>:
    D.6621 = hash->value_destroy_func;
    if (D.6621 != 0B) goto <D.6622>; else goto <D.6623>;
    <D.6622>:
    D.6621 = hash->value_destroy_func;
    D.6624 = s->value;
    D.6621 (D.6624);
    <D.6623>:
    monoeg_g_free (s);
    s = next;
    <D.6250>:
    if (s != 0B) goto <D.6249>; else goto <D.6251>;
    <D.6251>:
  }
  i = i + 1;
  <D.6253>:
  D.6625 = hash->table_size;
  if (D.6625 > i) goto <D.6252>; else goto <D.6254>;
  <D.6254>:
  D.6613 = hash->table;
  monoeg_g_free (D.6613);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.6627;
  long unsigned int D.6628;
  long unsigned int D.6629;
  struct Slot * * D.6630;
  int D.6633;
  int D.6634;
  int i;
  int max_chain_index;
  int chain_size;
  int max_chain_size;
  struct Slot * node;

  max_chain_size = 0;
  max_chain_index = -1;
  i = 0;
  goto <D.6267>;
  <D.6266>:
  chain_size = 0;
  D.6627 = table->table;
  D.6628 = (long unsigned int) i;
  D.6629 = D.6628 * 8;
  D.6630 = D.6627 + D.6629;
  node = *D.6630;
  goto <D.6264>;
  <D.6263>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.6264>:
  if (node != 0B) goto <D.6263>; else goto <D.6265>;
  <D.6265>:
  if (chain_size > max_chain_size) goto <D.6631>; else goto <D.6632>;
  <D.6631>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.6632>:
  i = i + 1;
  <D.6267>:
  D.6633 = table->table_size;
  if (D.6633 > i) goto <D.6266>; else goto <D.6268>;
  <D.6268>:
  D.6633 = table->table_size;
  D.6634 = table->in_use;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.6634, D.6633, max_chain_size, max_chain_index);
}


printf (const char * restrict __fmt)
{
  int D.6635;

  D.6635 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.6635;
}


monoeg_g_hash_table_iter_init (struct GHashTableIter * it, struct GHashTable * hash_table)
{
  struct Iter * iter;

  iter = it;
  memset (iter, 0, 24);
  iter->ht = hash_table;
  iter->slot_index = -1;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.6639;
  int D.6644;
  void * D.6646;
  long unsigned int D.6647;

  D.6639 = __builtin_constant_p (__len);
  if (D.6639 != 0) goto <D.6640>; else goto <D.6641>;
  <D.6640>:
  if (__len == 0) goto <D.6642>; else goto <D.6643>;
  <D.6642>:
  D.6644 = __builtin_constant_p (__ch);
  if (D.6644 == 0) goto <D.6637>; else goto <D.6645>;
  <D.6645>:
  if (__ch != 0) goto <D.6637>; else goto <D.6638>;
  <D.6637>:
  __warn_memset_zero_len ();
  D.6646 = __dest;
  return D.6646;
  <D.6638>:
  <D.6643>:
  <D.6641>:
  D.6647 = __builtin_object_size (__dest, 0);
  D.6646 = __builtin___memset_chk (__dest, __ch, __len, D.6647);
  return D.6646;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.6649;
  _Bool D.6650;
  long int D.6651;
  long int D.6652;
  struct Slot * D.6657;
  int D.6660;
  int D.6661;
  gboolean D.6664;
  struct Slot * * D.6665;
  long unsigned int D.6666;
  long unsigned int D.6667;
  struct Slot * * D.6668;
  struct Slot * D.6669;
  void * D.6673;
  void * D.6676;
  struct Slot * D.6677;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.6649 = iter->slot_index;
  D.6650 = D.6649 == -2;
  D.6651 = (long int) D.6650;
  D.6652 = __builtin_expect (D.6651, 0);
  if (D.6652 != 0) goto <D.6653>; else goto <D.6654>;
  <D.6653>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.6654>:
  if (0 != 0) goto <D.6655>; else goto <D.6656>;
  <D.6655>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.6656>:
  D.6657 = iter->slot;
  if (D.6657 == 0B) goto <D.6658>; else goto <D.6659>;
  <D.6658>:
  <D.6282>:
  D.6649 = iter->slot_index;
  D.6660 = D.6649 + 1;
  iter->slot_index = D.6660;
  D.6649 = iter->slot_index;
  D.6661 = hash->table_size;
  if (D.6649 >= D.6661) goto <D.6662>; else goto <D.6663>;
  <D.6662>:
  iter->slot_index = -2;
  D.6664 = 0;
  return D.6664;
  <D.6663>:
  D.6665 = hash->table;
  D.6649 = iter->slot_index;
  D.6666 = (long unsigned int) D.6649;
  D.6667 = D.6666 * 8;
  D.6668 = D.6665 + D.6667;
  D.6669 = *D.6668;
  if (D.6669 != 0B) goto <D.6281>; else goto <D.6670>;
  <D.6670>:
  goto <D.6282>;
  <D.6281>:
  D.6665 = hash->table;
  D.6649 = iter->slot_index;
  D.6666 = (long unsigned int) D.6649;
  D.6667 = D.6666 * 8;
  D.6668 = D.6665 + D.6667;
  D.6669 = *D.6668;
  iter->slot = D.6669;
  <D.6659>:
  if (key != 0B) goto <D.6671>; else goto <D.6672>;
  <D.6671>:
  D.6657 = iter->slot;
  D.6673 = D.6657->key;
  *key = D.6673;
  <D.6672>:
  if (value != 0B) goto <D.6674>; else goto <D.6675>;
  <D.6674>:
  D.6657 = iter->slot;
  D.6676 = D.6657->value;
  *value = D.6676;
  <D.6675>:
  D.6657 = iter->slot;
  D.6677 = D.6657->next;
  iter->slot = D.6677;
  D.6664 = 1;
  return D.6664;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.6679;
  _Bool D.6680;

  D.6680 = v1 == v2;
  D.6679 = (gboolean) D.6680;
  return D.6679;
}


monoeg_g_direct_hash (const void * v1)
{
  guint D.6682;
  long int v1.4;

  v1.4 = (long int) v1;
  D.6682 = (guint) v1.4;
  return D.6682;
}


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.6685;
  int D.6686;
  int D.6687;
  _Bool D.6688;

  D.6686 = MEM[(gint *)v1];
  D.6687 = MEM[(gint *)v2];
  D.6688 = D.6686 == D.6687;
  D.6685 = (gboolean) D.6688;
  return D.6685;
}


monoeg_g_int_hash (const void * v1)
{
  guint D.6690;

  D.6690 = MEM[(guint *)v1];
  return D.6690;
}


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.6692;
  int D.6309;
  _Bool D.6693;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.6309 = __builtin_strcmp (v1, v2);
  }
  D.6693 = D.6309 == 0;
  D.6692 = (gboolean) D.6693;
  return D.6692;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.6695;
  char D.6696;
  unsigned int D.6697;
  unsigned int D.6698;
  char * p.5;
  char D.6700;
  guint D.6701;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.6316>;
  <D.6315>:
  D.6695 = hash << 5;
  D.6696 = *p;
  D.6697 = (unsigned int) D.6696;
  D.6698 = D.6697 + hash;
  hash = D.6695 - D.6698;
  <D.6316>:
  p.5 = p;
  p = p.5 + 1;
  D.6700 = *p.5;
  if (D.6700 != 0) goto <D.6315>; else goto <D.6317>;
  <D.6317>:
  D.6701 = hash;
  return D.6701;
}