monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.6841;
  guint D.6844;
  unsigned int i.0;
  int x.1;
  int D.6847;
  int i;

  i = 0;
  goto <D.6590>;
  <D.6589>:
  D.6841 = prime_tbl[i];
  if (D.6841 >= x) goto <D.6842>; else goto <D.6843>;
  <D.6842>:
  D.6844 = prime_tbl[i];
  return D.6844;
  <D.6843>:
  i = i + 1;
  <D.6590>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.6589>; else goto <D.6591>;
  <D.6591>:
  x.1 = (int) x;
  D.6847 = calc_prime (x.1);
  D.6844 = (guint) D.6847;
  return D.6844;
}


calc_prime (int x)
{
  int D.6849;
  int D.6850;
  int D.6853;
  int i;

  D.6849 = x & -2;
  i = D.6849 + -1;
  goto <D.6583>;
  <D.6582>:
  D.6850 = test_prime (i);
  if (D.6850 != 0) goto <D.6851>; else goto <D.6852>;
  <D.6851>:
  D.6853 = i;
  return D.6853;
  <D.6852>:
  i = i + 2;
  <D.6583>:
  if (i != 2147483647) goto <D.6582>; else goto <D.6584>;
  <D.6584>:
  D.6853 = x;
  return D.6853;
}


test_prime (int x)
{
  int D.6855;
  int D.6858;
  gboolean D.6861;
  double D.6862;
  double D.6863;
  int D.6864;
  _Bool D.6865;

  D.6855 = x & 1;
  if (D.6855 != 0) goto <D.6856>; else goto <D.6857>;
  <D.6856>:
  {
    int n;

    n = 3;
    goto <D.6576>;
    <D.6575>:
    D.6858 = x % n;
    if (D.6858 == 0) goto <D.6859>; else goto <D.6860>;
    <D.6859>:
    D.6861 = 0;
    return D.6861;
    <D.6860>:
    n = n + 2;
    <D.6576>:
    D.6862 = (double) x;
    D.6863 = sqrt (D.6862);
    D.6864 = (int) D.6863;
    if (D.6864 > n) goto <D.6575>; else goto <D.6577>;
    <D.6577>:
    D.6861 = 1;
    return D.6861;
  }
  <D.6857>:
  D.6865 = x == 2;
  D.6861 = (gboolean) D.6865;
  return D.6861;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.6871;
  int D.6872;
  int D.6873;
  long unsigned int D.6874;
  long unsigned int D.6875;
  void * D.6876;
  struct GHashTable * D.6877;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.6867>; else goto <D.6868>;
  <D.6867>:
  hash_func = monoeg_g_direct_hash;
  <D.6868>:
  if (key_equal_func == 0B) goto <D.6869>; else goto <D.6870>;
  <D.6869>:
  key_equal_func = monoeg_g_direct_equal;
  <D.6870>:
  hash = monoeg_malloc0 (56);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.6871 = monoeg_g_spaced_primes_closest (1);
  D.6872 = (int) D.6871;
  hash->table_size = D.6872;
  D.6873 = hash->table_size;
  D.6874 = (long unsigned int) D.6873;
  D.6875 = D.6874 * 8;
  D.6876 = monoeg_malloc0 (D.6875);
  hash->table = D.6876;
  D.6873 = hash->table_size;
  hash->last_rehash = D.6873;
  D.6877 = hash;
  return D.6877;
}


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.6881;
  struct GHashTable * hash;

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


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.6885;
  int D.6886;
  guint (*<Te8a>) (const void *) D.6889;
  unsigned int D.6890;
  int D.6891;
  unsigned int D.6892;
  struct Slot * * D.6893;
  long unsigned int D.6894;
  long unsigned int D.6895;
  struct Slot * * D.6896;
  void * D.6897;
  int D.6898;
  void (*<Tdde>) (void *) D.6903;
  void (*<Tdde>) (void *) D.6906;
  void * D.6909;
  struct Slot * D.6910;
  int D.6911;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.6883>; else goto <D.6884>;
  <D.6883>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.6884>:
  equal = hash->key_equal_func;
  D.6885 = hash->in_use;
  D.6886 = hash->threshold;
  if (D.6885 >= D.6886) goto <D.6887>; else goto <D.6888>;
  <D.6887>:
  rehash (hash);
  <D.6888>:
  D.6889 = hash->hash_func;
  D.6890 = D.6889 (key);
  D.6891 = hash->table_size;
  D.6892 = (unsigned int) D.6891;
  hashcode = D.6890 % D.6892;
  D.6893 = hash->table;
  D.6894 = (long unsigned int) hashcode;
  D.6895 = D.6894 * 8;
  D.6896 = D.6893 + D.6895;
  s = *D.6896;
  goto <D.6633>;
  <D.6632>:
  D.6897 = s->key;
  D.6898 = equal (D.6897, key);
  if (D.6898 != 0) goto <D.6899>; else goto <D.6900>;
  <D.6899>:
  if (replace != 0) goto <D.6901>; else goto <D.6902>;
  <D.6901>:
  D.6903 = hash->key_destroy_func;
  if (D.6903 != 0B) goto <D.6904>; else goto <D.6905>;
  <D.6904>:
  D.6903 = hash->key_destroy_func;
  D.6897 = s->key;
  D.6903 (D.6897);
  <D.6905>:
  s->key = key;
  <D.6902>:
  D.6906 = hash->value_destroy_func;
  if (D.6906 != 0B) goto <D.6907>; else goto <D.6908>;
  <D.6907>:
  D.6906 = hash->value_destroy_func;
  D.6909 = s->value;
  D.6906 (D.6909);
  <D.6908>:
  s->value = value;
  return;
  <D.6900>:
  s = s->next;
  <D.6633>:
  if (s != 0B) goto <D.6632>; else goto <D.6634>;
  <D.6634>:
  s = monoeg_malloc (24);
  s->key = key;
  s->value = value;
  D.6893 = hash->table;
  D.6894 = (long unsigned int) hashcode;
  D.6895 = D.6894 * 8;
  D.6896 = D.6893 + D.6895;
  D.6910 = *D.6896;
  s->next = D.6910;
  D.6893 = hash->table;
  D.6894 = (long unsigned int) hashcode;
  D.6895 = D.6894 * 8;
  D.6896 = D.6893 + D.6895;
  *D.6896 = s;
  D.6885 = hash->in_use;
  D.6911 = D.6885 + 1;
  hash->in_use = D.6911;
}


rehash (struct GHashTable * hash)
{
  int D.6913;
  int D.6914;
  int D.6915;
  double D.6916;
  double D.6917;
  int D.6918;
  int D.6919;
  double D.6920;
  _Bool D.6921;
  _Bool D.6922;
  int diff;

  D.6913 = hash->last_rehash;
  D.6914 = hash->in_use;
  D.6915 = D.6913 - D.6914;
  diff = ABS_EXPR <D.6915>;
  D.6916 = (double) diff;
  D.6917 = D.6916 * 7.5e-1;
  D.6918 = hash->table_size;
  D.6919 = D.6918 * 2;
  D.6920 = (double) D.6919;
  D.6921 = D.6917 > D.6920;
  D.6922 = ~D.6921;
  if (D.6922 != 0) goto <D.6923>; else goto <D.6924>;
  <D.6923>:
  return;
  <D.6924>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.6926;
  int D.6927;
  unsigned int D.6928;
  unsigned int D.6929;
  int D.6930;
  long unsigned int D.6931;
  long unsigned int D.6932;
  void * D.6933;
  long unsigned int D.6934;
  long unsigned int D.6935;
  struct Slot * * D.6936;
  guint (*<Te8a>) (const void *) D.6937;
  void * D.6938;
  unsigned int D.6939;
  unsigned int D.6940;
  struct Slot * * D.6941;
  long unsigned int D.6942;
  long unsigned int D.6943;
  struct Slot * * D.6944;
  struct Slot * D.6945;
  int current_size;
  int i;
  struct Slot * * table;

  D.6926 = hash->table_size;
  hash->last_rehash = D.6926;
  current_size = hash->table_size;
  D.6927 = hash->in_use;
  D.6928 = (unsigned int) D.6927;
  D.6929 = monoeg_g_spaced_primes_closest (D.6928);
  D.6930 = (int) D.6929;
  hash->table_size = D.6930;
  table = hash->table;
  D.6926 = hash->table_size;
  D.6931 = (long unsigned int) D.6926;
  D.6932 = D.6931 * 8;
  D.6933 = monoeg_malloc0 (D.6932);
  hash->table = D.6933;
  i = 0;
  goto <D.6617>;
  <D.6616>:
  {
    struct Slot * s;
    struct Slot * next;

    D.6934 = (long unsigned int) i;
    D.6935 = D.6934 * 8;
    D.6936 = table + D.6935;
    s = *D.6936;
    goto <D.6614>;
    <D.6613>:
    {
      guint hashcode;

      D.6937 = hash->hash_func;
      D.6938 = s->key;
      D.6939 = D.6937 (D.6938);
      D.6926 = hash->table_size;
      D.6940 = (unsigned int) D.6926;
      hashcode = D.6939 % D.6940;
      next = s->next;
      D.6941 = hash->table;
      D.6942 = (long unsigned int) hashcode;
      D.6943 = D.6942 * 8;
      D.6944 = D.6941 + D.6943;
      D.6945 = *D.6944;
      s->next = D.6945;
      D.6941 = hash->table;
      D.6942 = (long unsigned int) hashcode;
      D.6943 = D.6942 * 8;
      D.6944 = D.6941 + D.6943;
      *D.6944 = s;
    }
    s = next;
    <D.6614>:
    if (s != 0B) goto <D.6613>; else goto <D.6615>;
    <D.6615>:
  }
  i = i + 1;
  <D.6617>:
  if (i < current_size) goto <D.6616>; else goto <D.6618>;
  <D.6618>:
  monoeg_g_free (table);
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6642>;
      <D.6641>:
      key.2 = key;
      rv = monoeg_g_list_prepend (rv, key.2);
      <D.6642>:
      D.6947 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.6947 != 0) goto <D.6641>; else goto <D.6643>;
      <D.6643>:
      D.6948 = monoeg_g_list_reverse (rv);
      return D.6948;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6651>;
      <D.6650>:
      value.3 = value;
      rv = monoeg_g_list_prepend (rv, value.3);
      <D.6651>:
      D.6952 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.6952 != 0) goto <D.6650>; else goto <D.6652>;
      <D.6652>:
      D.6953 = monoeg_g_list_reverse (rv);
      return D.6953;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.6958;
  int D.6959;

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


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

  try
    {
      D.6961 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.6961 != 0) goto <D.6962>; else goto <D.6963>;
      <D.6962>:
      D.6964 = value;
      return D.6964;
      <D.6963>:
      D.6964 = 0B;
      return D.6964;
    }
  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.6969;
  guint (*<Te8a>) (const void *) D.6970;
  unsigned int D.6971;
  int D.6972;
  unsigned int D.6973;
  struct Slot * * D.6974;
  long unsigned int D.6975;
  long unsigned int D.6976;
  struct Slot * * D.6977;
  void * D.6978;
  int D.6979;
  void * D.6986;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.6967>; else goto <D.6968>;
  <D.6967>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.6969 = 0;
  return D.6969;
  <D.6968>:
  equal = hash->key_equal_func;
  D.6970 = hash->hash_func;
  D.6971 = D.6970 (key);
  D.6972 = hash->table_size;
  D.6973 = (unsigned int) D.6972;
  hashcode = D.6971 % D.6973;
  D.6974 = hash->table;
  D.6975 = (long unsigned int) hashcode;
  D.6976 = D.6975 * 8;
  D.6977 = D.6974 + D.6976;
  s = *D.6977;
  goto <D.6672>;
  <D.6671>:
  D.6978 = s->key;
  D.6979 = equal (D.6978, key);
  if (D.6979 != 0) goto <D.6980>; else goto <D.6981>;
  <D.6980>:
  if (orig_key != 0B) goto <D.6982>; else goto <D.6983>;
  <D.6982>:
  D.6978 = s->key;
  *orig_key = D.6978;
  <D.6983>:
  if (value != 0B) goto <D.6984>; else goto <D.6985>;
  <D.6984>:
  D.6986 = s->value;
  *value = D.6986;
  <D.6985>:
  D.6969 = 1;
  return D.6969;
  <D.6981>:
  s = s->next;
  <D.6672>:
  if (s != 0B) goto <D.6671>; else goto <D.6673>;
  <D.6673>:
  D.6969 = 0;
  return D.6969;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.6992;
  long unsigned int D.6993;
  long unsigned int D.6994;
  struct Slot * * D.6995;
  void * D.6996;
  void * D.6997;
  int D.6998;
  int i;

  if (hash == 0B) goto <D.6988>; else goto <D.6989>;
  <D.6988>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.6989>:
  if (func == 0B) goto <D.6990>; else goto <D.6991>;
  <D.6990>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.6991>:
  i = 0;
  goto <D.6685>;
  <D.6684>:
  {
    struct Slot * s;

    D.6992 = hash->table;
    D.6993 = (long unsigned int) i;
    D.6994 = D.6993 * 8;
    D.6995 = D.6992 + D.6994;
    s = *D.6995;
    goto <D.6682>;
    <D.6681>:
    D.6996 = s->key;
    D.6997 = s->value;
    func (D.6996, D.6997, user_data);
    s = s->next;
    <D.6682>:
    if (s != 0B) goto <D.6681>; else goto <D.6683>;
    <D.6683>:
  }
  i = i + 1;
  <D.6685>:
  D.6998 = hash->table_size;
  if (D.6998 > i) goto <D.6684>; else goto <D.6686>;
  <D.6686>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.7002;
  struct Slot * * D.7005;
  long unsigned int D.7006;
  long unsigned int D.7007;
  struct Slot * * D.7008;
  void * D.7009;
  void * D.7010;
  int D.7011;
  int D.7014;
  int i;

  if (hash == 0B) goto <D.7000>; else goto <D.7001>;
  <D.7000>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.7002 = 0B;
  return D.7002;
  <D.7001>:
  if (predicate == 0B) goto <D.7003>; else goto <D.7004>;
  <D.7003>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.7002 = 0B;
  return D.7002;
  <D.7004>:
  i = 0;
  goto <D.6698>;
  <D.6697>:
  {
    struct Slot * s;

    D.7005 = hash->table;
    D.7006 = (long unsigned int) i;
    D.7007 = D.7006 * 8;
    D.7008 = D.7005 + D.7007;
    s = *D.7008;
    goto <D.6695>;
    <D.6694>:
    D.7009 = s->key;
    D.7010 = s->value;
    D.7011 = predicate (D.7009, D.7010, user_data);
    if (D.7011 != 0) goto <D.7012>; else goto <D.7013>;
    <D.7012>:
    D.7002 = s->value;
    return D.7002;
    <D.7013>:
    s = s->next;
    <D.6695>:
    if (s != 0B) goto <D.6694>; else goto <D.6696>;
    <D.6696>:
  }
  i = i + 1;
  <D.6698>:
  D.7014 = hash->table_size;
  if (D.7014 > i) goto <D.6697>; else goto <D.6699>;
  <D.6699>:
  D.7002 = 0B;
  return D.7002;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.7018;
  long unsigned int D.7019;
  long unsigned int D.7020;
  struct Slot * * D.7021;
  void * D.7022;
  struct Slot * D.7023;
  int D.7024;
  int i;

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

    goto <D.6706>;
    <D.6705>:
    D.7018 = hash->table;
    D.7019 = (long unsigned int) i;
    D.7020 = D.7019 * 8;
    D.7021 = D.7018 + D.7020;
    s = *D.7021;
    D.7022 = s->key;
    monoeg_g_hash_table_remove (hash, D.7022);
    <D.6706>:
    D.7018 = hash->table;
    D.7019 = (long unsigned int) i;
    D.7020 = D.7019 * 8;
    D.7021 = D.7018 + D.7020;
    D.7023 = *D.7021;
    if (D.7023 != 0B) goto <D.6705>; else goto <D.6707>;
    <D.6707>:
  }
  i = i + 1;
  <D.6709>:
  D.7024 = hash->table_size;
  if (D.7024 > i) goto <D.6708>; else goto <D.6710>;
  <D.6710>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.7028;
  guint (*<Te8a>) (const void *) D.7029;
  unsigned int D.7030;
  int D.7031;
  unsigned int D.7032;
  struct Slot * * D.7033;
  long unsigned int D.7034;
  long unsigned int D.7035;
  struct Slot * * D.7036;
  void * D.7037;
  int D.7038;
  void (*<Tdde>) (void *) D.7041;
  void (*<Tdde>) (void *) D.7044;
  void * D.7047;
  struct Slot * D.7050;
  int D.7052;
  int D.7053;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.7026>; else goto <D.7027>;
  <D.7026>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.7028 = 0;
  return D.7028;
  <D.7027>:
  equal = hash->key_equal_func;
  D.7029 = hash->hash_func;
  D.7030 = D.7029 (key);
  D.7031 = hash->table_size;
  D.7032 = (unsigned int) D.7031;
  hashcode = D.7030 % D.7032;
  last = 0B;
  D.7033 = hash->table;
  D.7034 = (long unsigned int) hashcode;
  D.7035 = D.7034 * 8;
  D.7036 = D.7033 + D.7035;
  s = *D.7036;
  goto <D.6720>;
  <D.6719>:
  D.7037 = s->key;
  D.7038 = equal (D.7037, key);
  if (D.7038 != 0) goto <D.7039>; else goto <D.7040>;
  <D.7039>:
  D.7041 = hash->key_destroy_func;
  if (D.7041 != 0B) goto <D.7042>; else goto <D.7043>;
  <D.7042>:
  D.7041 = hash->key_destroy_func;
  D.7037 = s->key;
  D.7041 (D.7037);
  <D.7043>:
  D.7044 = hash->value_destroy_func;
  if (D.7044 != 0B) goto <D.7045>; else goto <D.7046>;
  <D.7045>:
  D.7044 = hash->value_destroy_func;
  D.7047 = s->value;
  D.7044 (D.7047);
  <D.7046>:
  if (last == 0B) goto <D.7048>; else goto <D.7049>;
  <D.7048>:
  D.7033 = hash->table;
  D.7034 = (long unsigned int) hashcode;
  D.7035 = D.7034 * 8;
  D.7036 = D.7033 + D.7035;
  D.7050 = s->next;
  *D.7036 = D.7050;
  goto <D.7051>;
  <D.7049>:
  D.7050 = s->next;
  last->next = D.7050;
  <D.7051>:
  monoeg_g_free (s);
  D.7052 = hash->in_use;
  D.7053 = D.7052 + -1;
  hash->in_use = D.7053;
  D.7028 = 1;
  return D.7028;
  <D.7040>:
  last = s;
  s = s->next;
  <D.6720>:
  if (s != 0B) goto <D.6719>; else goto <D.6721>;
  <D.6721>:
  D.7028 = 0;
  return D.7028;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.7057;
  struct Slot * * D.7060;
  long unsigned int D.7061;
  long unsigned int D.7062;
  struct Slot * * D.7063;
  void * D.7064;
  void * D.7065;
  int D.7066;
  void (*<Tdde>) (void *) D.7069;
  void (*<Tdde>) (void *) D.7072;
  struct Slot * D.7077;
  int D.7079;
  int D.7080;
  int D.7082;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.7055>; else goto <D.7056>;
  <D.7055>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.7057 = 0;
  return D.7057;
  <D.7056>:
  if (func == 0B) goto <D.7058>; else goto <D.7059>;
  <D.7058>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.7057 = 0;
  return D.7057;
  <D.7059>:
  i = 0;
  goto <D.6736>;
  <D.6735>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.7060 = hash->table;
    D.7061 = (long unsigned int) i;
    D.7062 = D.7061 * 8;
    D.7063 = D.7060 + D.7062;
    s = *D.7063;
    goto <D.6733>;
    <D.6732>:
    D.7064 = s->key;
    D.7065 = s->value;
    D.7066 = func (D.7064, D.7065, user_data);
    if (D.7066 != 0) goto <D.7067>; else goto <D.7068>;
    <D.7067>:
    {
      struct Slot * n;

      D.7069 = hash->key_destroy_func;
      if (D.7069 != 0B) goto <D.7070>; else goto <D.7071>;
      <D.7070>:
      D.7069 = hash->key_destroy_func;
      D.7064 = s->key;
      D.7069 (D.7064);
      <D.7071>:
      D.7072 = hash->value_destroy_func;
      if (D.7072 != 0B) goto <D.7073>; else goto <D.7074>;
      <D.7073>:
      D.7072 = hash->value_destroy_func;
      D.7065 = s->value;
      D.7072 (D.7065);
      <D.7074>:
      if (last == 0B) goto <D.7075>; else goto <D.7076>;
      <D.7075>:
      D.7060 = hash->table;
      D.7061 = (long unsigned int) i;
      D.7062 = D.7061 * 8;
      D.7063 = D.7060 + D.7062;
      D.7077 = s->next;
      *D.7063 = D.7077;
      n = s->next;
      goto <D.7078>;
      <D.7076>:
      D.7077 = s->next;
      last->next = D.7077;
      n = last->next;
      <D.7078>:
      monoeg_g_free (s);
      D.7079 = hash->in_use;
      D.7080 = D.7079 + -1;
      hash->in_use = D.7080;
      count = count + 1;
      s = n;
    }
    goto <D.7081>;
    <D.7068>:
    last = s;
    s = s->next;
    <D.7081>:
    <D.6733>:
    if (s != 0B) goto <D.6732>; else goto <D.6734>;
    <D.6734>:
  }
  i = i + 1;
  <D.6736>:
  D.7082 = hash->table_size;
  if (D.7082 > i) goto <D.6735>; else goto <D.6737>;
  <D.6737>:
  if (count > 0) goto <D.7083>; else goto <D.7084>;
  <D.7083>:
  rehash (hash);
  <D.7084>:
  D.7057 = (guint) count;
  return D.7057;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.7088;
  guint (*<Te8a>) (const void *) D.7089;
  unsigned int D.7090;
  int D.7091;
  unsigned int D.7092;
  struct Slot * * D.7093;
  long unsigned int D.7094;
  long unsigned int D.7095;
  struct Slot * * D.7096;
  void * D.7097;
  int D.7098;
  struct Slot * D.7103;
  int D.7105;
  int D.7106;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.7086>; else goto <D.7087>;
  <D.7086>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.7088 = 0;
  return D.7088;
  <D.7087>:
  equal = hash->key_equal_func;
  D.7089 = hash->hash_func;
  D.7090 = D.7089 (key);
  D.7091 = hash->table_size;
  D.7092 = (unsigned int) D.7091;
  hashcode = D.7090 % D.7092;
  last = 0B;
  D.7093 = hash->table;
  D.7094 = (long unsigned int) hashcode;
  D.7095 = D.7094 * 8;
  D.7096 = D.7093 + D.7095;
  s = *D.7096;
  goto <D.6747>;
  <D.6746>:
  D.7097 = s->key;
  D.7098 = equal (D.7097, key);
  if (D.7098 != 0) goto <D.7099>; else goto <D.7100>;
  <D.7099>:
  if (last == 0B) goto <D.7101>; else goto <D.7102>;
  <D.7101>:
  D.7093 = hash->table;
  D.7094 = (long unsigned int) hashcode;
  D.7095 = D.7094 * 8;
  D.7096 = D.7093 + D.7095;
  D.7103 = s->next;
  *D.7096 = D.7103;
  goto <D.7104>;
  <D.7102>:
  D.7103 = s->next;
  last->next = D.7103;
  <D.7104>:
  monoeg_g_free (s);
  D.7105 = hash->in_use;
  D.7106 = D.7105 + -1;
  hash->in_use = D.7106;
  D.7088 = 1;
  return D.7088;
  <D.7100>:
  last = s;
  s = s->next;
  <D.6747>:
  if (s != 0B) goto <D.6746>; else goto <D.6748>;
  <D.6748>:
  D.7088 = 0;
  return D.7088;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.7110;
  struct Slot * * D.7113;
  long unsigned int D.7114;
  long unsigned int D.7115;
  struct Slot * * D.7116;
  void * D.7117;
  void * D.7118;
  int D.7119;
  struct Slot * D.7124;
  int D.7126;
  int D.7127;
  int D.7129;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.7108>; else goto <D.7109>;
  <D.7108>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.7110 = 0;
  return D.7110;
  <D.7109>:
  if (func == 0B) goto <D.7111>; else goto <D.7112>;
  <D.7111>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.7110 = 0;
  return D.7110;
  <D.7112>:
  i = 0;
  goto <D.6763>;
  <D.6762>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.7113 = hash->table;
    D.7114 = (long unsigned int) i;
    D.7115 = D.7114 * 8;
    D.7116 = D.7113 + D.7115;
    s = *D.7116;
    goto <D.6760>;
    <D.6759>:
    D.7117 = s->key;
    D.7118 = s->value;
    D.7119 = func (D.7117, D.7118, user_data);
    if (D.7119 != 0) goto <D.7120>; else goto <D.7121>;
    <D.7120>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.7122>; else goto <D.7123>;
      <D.7122>:
      D.7113 = hash->table;
      D.7114 = (long unsigned int) i;
      D.7115 = D.7114 * 8;
      D.7116 = D.7113 + D.7115;
      D.7124 = s->next;
      *D.7116 = D.7124;
      n = s->next;
      goto <D.7125>;
      <D.7123>:
      D.7124 = s->next;
      last->next = D.7124;
      n = last->next;
      <D.7125>:
      monoeg_g_free (s);
      D.7126 = hash->in_use;
      D.7127 = D.7126 + -1;
      hash->in_use = D.7127;
      count = count + 1;
      s = n;
    }
    goto <D.7128>;
    <D.7121>:
    last = s;
    s = s->next;
    <D.7128>:
    <D.6760>:
    if (s != 0B) goto <D.6759>; else goto <D.6761>;
    <D.6761>:
  }
  i = i + 1;
  <D.6763>:
  D.7129 = hash->table_size;
  if (D.7129 > i) goto <D.6762>; else goto <D.6764>;
  <D.6764>:
  if (count > 0) goto <D.7130>; else goto <D.7131>;
  <D.7130>:
  rehash (hash);
  <D.7131>:
  D.7110 = (guint) count;
  return D.7110;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.7135;
  long unsigned int D.7136;
  long unsigned int D.7137;
  struct Slot * * D.7138;
  void (*<Tdde>) (void *) D.7139;
  void * D.7142;
  void (*<Tdde>) (void *) D.7143;
  void * D.7146;
  int D.7147;
  int i;

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

    D.7135 = hash->table;
    D.7136 = (long unsigned int) i;
    D.7137 = D.7136 * 8;
    D.7138 = D.7135 + D.7137;
    s = *D.7138;
    goto <D.6772>;
    <D.6771>:
    next = s->next;
    D.7139 = hash->key_destroy_func;
    if (D.7139 != 0B) goto <D.7140>; else goto <D.7141>;
    <D.7140>:
    D.7139 = hash->key_destroy_func;
    D.7142 = s->key;
    D.7139 (D.7142);
    <D.7141>:
    D.7143 = hash->value_destroy_func;
    if (D.7143 != 0B) goto <D.7144>; else goto <D.7145>;
    <D.7144>:
    D.7143 = hash->value_destroy_func;
    D.7146 = s->value;
    D.7143 (D.7146);
    <D.7145>:
    monoeg_g_free (s);
    s = next;
    <D.6772>:
    if (s != 0B) goto <D.6771>; else goto <D.6773>;
    <D.6773>:
  }
  i = i + 1;
  <D.6775>:
  D.7147 = hash->table_size;
  if (D.7147 > i) goto <D.6774>; else goto <D.6776>;
  <D.6776>:
  D.7135 = hash->table;
  monoeg_g_free (D.7135);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.7149;
  long unsigned int D.7150;
  long unsigned int D.7151;
  struct Slot * * D.7152;
  int D.7155;
  int D.7156;
  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.6789>;
  <D.6788>:
  chain_size = 0;
  D.7149 = table->table;
  D.7150 = (long unsigned int) i;
  D.7151 = D.7150 * 8;
  D.7152 = D.7149 + D.7151;
  node = *D.7152;
  goto <D.6786>;
  <D.6785>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.6786>:
  if (node != 0B) goto <D.6785>; else goto <D.6787>;
  <D.6787>:
  if (chain_size > max_chain_size) goto <D.7153>; else goto <D.7154>;
  <D.7153>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.7154>:
  i = i + 1;
  <D.6789>:
  D.7155 = table->table_size;
  if (D.7155 > i) goto <D.6788>; else goto <D.6790>;
  <D.6790>:
  D.7156 = table->in_use;
  D.7155 = table->table_size;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.7156, D.7155, max_chain_size, max_chain_index);
}


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

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


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.7161;
  int D.7166;
  void * D.7168;
  long unsigned int D.7169;

  D.7161 = __builtin_constant_p (__len);
  if (D.7161 != 0) goto <D.7162>; else goto <D.7163>;
  <D.7162>:
  if (__len == 0) goto <D.7164>; else goto <D.7165>;
  <D.7164>:
  D.7166 = __builtin_constant_p (__ch);
  if (D.7166 == 0) goto <D.7159>; else goto <D.7167>;
  <D.7167>:
  if (__ch != 0) goto <D.7159>; else goto <D.7160>;
  <D.7159>:
  __warn_memset_zero_len ();
  D.7168 = __dest;
  return D.7168;
  <D.7160>:
  <D.7165>:
  <D.7163>:
  D.7169 = __builtin_object_size (__dest, 0);
  D.7168 = __builtin___memset_chk (__dest, __ch, __len, D.7169);
  return D.7168;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.7171;
  _Bool D.7172;
  long int D.7173;
  long int D.7174;
  struct Slot * D.7179;
  int D.7182;
  int D.7183;
  gboolean D.7186;
  struct Slot * * D.7187;
  long unsigned int D.7188;
  long unsigned int D.7189;
  struct Slot * * D.7190;
  struct Slot * D.7191;
  void * D.7195;
  void * D.7198;
  struct Slot * D.7199;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.7171 = iter->slot_index;
  D.7172 = D.7171 == -2;
  D.7173 = (long int) D.7172;
  D.7174 = __builtin_expect (D.7173, 0);
  if (D.7174 != 0) goto <D.7175>; else goto <D.7176>;
  <D.7175>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.7176>:
  if (0 != 0) goto <D.7177>; else goto <D.7178>;
  <D.7177>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.7178>:
  D.7179 = iter->slot;
  if (D.7179 == 0B) goto <D.7180>; else goto <D.7181>;
  <D.7180>:
  <D.6804>:
  D.7171 = iter->slot_index;
  D.7182 = D.7171 + 1;
  iter->slot_index = D.7182;
  D.7171 = iter->slot_index;
  D.7183 = hash->table_size;
  if (D.7171 >= D.7183) goto <D.7184>; else goto <D.7185>;
  <D.7184>:
  iter->slot_index = -2;
  D.7186 = 0;
  return D.7186;
  <D.7185>:
  D.7187 = hash->table;
  D.7171 = iter->slot_index;
  D.7188 = (long unsigned int) D.7171;
  D.7189 = D.7188 * 8;
  D.7190 = D.7187 + D.7189;
  D.7191 = *D.7190;
  if (D.7191 != 0B) goto <D.6803>; else goto <D.7192>;
  <D.7192>:
  goto <D.6804>;
  <D.6803>:
  D.7187 = hash->table;
  D.7171 = iter->slot_index;
  D.7188 = (long unsigned int) D.7171;
  D.7189 = D.7188 * 8;
  D.7190 = D.7187 + D.7189;
  D.7191 = *D.7190;
  iter->slot = D.7191;
  <D.7181>:
  if (key != 0B) goto <D.7193>; else goto <D.7194>;
  <D.7193>:
  D.7179 = iter->slot;
  D.7195 = D.7179->key;
  *key = D.7195;
  <D.7194>:
  if (value != 0B) goto <D.7196>; else goto <D.7197>;
  <D.7196>:
  D.7179 = iter->slot;
  D.7198 = D.7179->value;
  *value = D.7198;
  <D.7197>:
  D.7179 = iter->slot;
  D.7199 = D.7179->next;
  iter->slot = D.7199;
  D.7186 = 1;
  return D.7186;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.7201;
  _Bool D.7202;

  D.7202 = v1 == v2;
  D.7201 = (gboolean) D.7202;
  return D.7201;
}


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

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


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.7207;
  int D.7208;
  int D.7209;
  _Bool D.7210;

  D.7208 = MEM[(gint *)v1];
  D.7209 = MEM[(gint *)v2];
  D.7210 = D.7208 == D.7209;
  D.7207 = (gboolean) D.7210;
  return D.7207;
}


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

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


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.7214;
  int D.6831;
  _Bool D.7215;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.6831 = __builtin_strcmp (v1, v2);
  }
  D.7215 = D.6831 == 0;
  D.7214 = (gboolean) D.7215;
  return D.7214;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.7217;
  char D.7218;
  unsigned int D.7219;
  unsigned int D.7220;
  char * p.5;
  char D.7222;
  guint D.7223;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.6838>;
  <D.6837>:
  D.7217 = hash << 5;
  D.7218 = *p;
  D.7219 = (unsigned int) D.7218;
  D.7220 = D.7219 + hash;
  hash = D.7217 - D.7220;
  <D.6838>:
  p.5 = p;
  p = p.5 + 1;
  D.7222 = *p.5;
  if (D.7222 != 0) goto <D.6837>; else goto <D.6839>;
  <D.6839>:
  D.7223 = hash;
  return D.7223;
}