monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.8815;
  guint D.8818;
  unsigned int i.0;
  int x.1;
  int D.8821;
  int i;

  i = 0;
  goto <D.8562>;
  <D.8561>:
  D.8815 = prime_tbl[i];
  if (D.8815 >= x) goto <D.8816>; else goto <D.8817>;
  <D.8816>:
  D.8818 = prime_tbl[i];
  return D.8818;
  <D.8817>:
  i = i + 1;
  <D.8562>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.8561>; else goto <D.8563>;
  <D.8563>:
  x.1 = (int) x;
  D.8821 = calc_prime (x.1);
  D.8818 = (guint) D.8821;
  return D.8818;
}


calc_prime (int x)
{
  int D.8823;
  int D.8824;
  int D.8827;
  int i;

  D.8823 = x & -2;
  i = D.8823 + -1;
  goto <D.8555>;
  <D.8554>:
  D.8824 = test_prime (i);
  if (D.8824 != 0) goto <D.8825>; else goto <D.8826>;
  <D.8825>:
  D.8827 = i;
  return D.8827;
  <D.8826>:
  i = i + 2;
  <D.8555>:
  if (i != 2147483647) goto <D.8554>; else goto <D.8556>;
  <D.8556>:
  D.8827 = x;
  return D.8827;
}


test_prime (int x)
{
  int D.8829;
  int D.8832;
  gboolean D.8835;
  double D.8836;
  double D.8837;
  int D.8838;
  _Bool D.8839;

  D.8829 = x & 1;
  if (D.8829 != 0) goto <D.8830>; else goto <D.8831>;
  <D.8830>:
  {
    int n;

    n = 3;
    goto <D.8548>;
    <D.8547>:
    D.8832 = x % n;
    if (D.8832 == 0) goto <D.8833>; else goto <D.8834>;
    <D.8833>:
    D.8835 = 0;
    return D.8835;
    <D.8834>:
    n = n + 2;
    <D.8548>:
    D.8836 = (double) x;
    D.8837 = sqrt (D.8836);
    D.8838 = (int) D.8837;
    if (D.8838 > n) goto <D.8547>; else goto <D.8549>;
    <D.8549>:
    D.8835 = 1;
    return D.8835;
  }
  <D.8831>:
  D.8839 = x == 2;
  D.8835 = (gboolean) D.8839;
  return D.8835;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.8845;
  int D.8846;
  int D.8847;
  unsigned int D.8848;
  unsigned int D.8849;
  void * D.8850;
  struct GHashTable * D.8851;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.8841>; else goto <D.8842>;
  <D.8841>:
  hash_func = monoeg_g_direct_hash;
  <D.8842>:
  if (key_equal_func == 0B) goto <D.8843>; else goto <D.8844>;
  <D.8843>:
  key_equal_func = monoeg_g_direct_equal;
  <D.8844>:
  hash = monoeg_malloc0 (36);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.8845 = monoeg_g_spaced_primes_closest (1);
  D.8846 = (int) D.8845;
  hash->table_size = D.8846;
  D.8847 = hash->table_size;
  D.8848 = (unsigned int) D.8847;
  D.8849 = D.8848 * 4;
  D.8850 = monoeg_malloc0 (D.8849);
  hash->table = D.8850;
  D.8847 = hash->table_size;
  hash->last_rehash = D.8847;
  D.8851 = hash;
  return D.8851;
}


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

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


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.8859;
  int D.8860;
  guint (*<T1895>) (const void *) D.8863;
  unsigned int D.8864;
  int D.8865;
  unsigned int D.8866;
  struct Slot * * D.8867;
  unsigned int D.8868;
  struct Slot * * D.8869;
  void * D.8870;
  int D.8871;
  void (*<T17e9>) (void *) D.8876;
  void (*<T17e9>) (void *) D.8879;
  void * D.8882;
  struct Slot * D.8883;
  int D.8884;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.8857>; else goto <D.8858>;
  <D.8857>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.8858>:
  equal = hash->key_equal_func;
  D.8859 = hash->in_use;
  D.8860 = hash->threshold;
  if (D.8859 >= D.8860) goto <D.8861>; else goto <D.8862>;
  <D.8861>:
  rehash (hash);
  <D.8862>:
  D.8863 = hash->hash_func;
  D.8864 = D.8863 (key);
  D.8865 = hash->table_size;
  D.8866 = (unsigned int) D.8865;
  hashcode = D.8864 % D.8866;
  D.8867 = hash->table;
  D.8868 = hashcode * 4;
  D.8869 = D.8867 + D.8868;
  s = *D.8869;
  goto <D.8605>;
  <D.8604>:
  D.8870 = s->key;
  D.8871 = equal (D.8870, key);
  if (D.8871 != 0) goto <D.8872>; else goto <D.8873>;
  <D.8872>:
  if (replace != 0) goto <D.8874>; else goto <D.8875>;
  <D.8874>:
  D.8876 = hash->key_destroy_func;
  if (D.8876 != 0B) goto <D.8877>; else goto <D.8878>;
  <D.8877>:
  D.8876 = hash->key_destroy_func;
  D.8870 = s->key;
  D.8876 (D.8870);
  <D.8878>:
  s->key = key;
  <D.8875>:
  D.8879 = hash->value_destroy_func;
  if (D.8879 != 0B) goto <D.8880>; else goto <D.8881>;
  <D.8880>:
  D.8879 = hash->value_destroy_func;
  D.8882 = s->value;
  D.8879 (D.8882);
  <D.8881>:
  s->value = value;
  return;
  <D.8873>:
  s = s->next;
  <D.8605>:
  if (s != 0B) goto <D.8604>; else goto <D.8606>;
  <D.8606>:
  s = monoeg_malloc (12);
  s->key = key;
  s->value = value;
  D.8867 = hash->table;
  D.8868 = hashcode * 4;
  D.8869 = D.8867 + D.8868;
  D.8883 = *D.8869;
  s->next = D.8883;
  D.8867 = hash->table;
  D.8868 = hashcode * 4;
  D.8869 = D.8867 + D.8868;
  *D.8869 = s;
  D.8859 = hash->in_use;
  D.8884 = D.8859 + 1;
  hash->in_use = D.8884;
}


rehash (struct GHashTable * hash)
{
  int D.8886;
  int D.8887;
  int D.8888;
  double D.8889;
  double D.8890;
  int D.8891;
  int D.8892;
  double D.8893;
  _Bool D.8894;
  _Bool D.8895;
  int diff;

  D.8886 = hash->last_rehash;
  D.8887 = hash->in_use;
  D.8888 = D.8886 - D.8887;
  diff = ABS_EXPR <D.8888>;
  D.8889 = (double) diff;
  D.8890 = D.8889 * 7.5e-1;
  D.8891 = hash->table_size;
  D.8892 = D.8891 * 2;
  D.8893 = (double) D.8892;
  D.8894 = D.8890 > D.8893;
  D.8895 = ~D.8894;
  if (D.8895 != 0) goto <D.8896>; else goto <D.8897>;
  <D.8896>:
  return;
  <D.8897>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.8899;
  int D.8900;
  unsigned int D.8901;
  unsigned int D.8902;
  int D.8903;
  unsigned int D.8904;
  unsigned int D.8905;
  void * D.8906;
  unsigned int i.2;
  unsigned int D.8908;
  struct Slot * * D.8909;
  guint (*<T1895>) (const void *) D.8910;
  void * D.8911;
  unsigned int D.8912;
  unsigned int D.8913;
  struct Slot * * D.8914;
  unsigned int D.8915;
  struct Slot * * D.8916;
  struct Slot * D.8917;
  int current_size;
  int i;
  struct Slot * * table;

  D.8899 = hash->table_size;
  hash->last_rehash = D.8899;
  current_size = hash->table_size;
  D.8900 = hash->in_use;
  D.8901 = (unsigned int) D.8900;
  D.8902 = monoeg_g_spaced_primes_closest (D.8901);
  D.8903 = (int) D.8902;
  hash->table_size = D.8903;
  table = hash->table;
  D.8899 = hash->table_size;
  D.8904 = (unsigned int) D.8899;
  D.8905 = D.8904 * 4;
  D.8906 = monoeg_malloc0 (D.8905);
  hash->table = D.8906;
  i = 0;
  goto <D.8589>;
  <D.8588>:
  {
    struct Slot * s;
    struct Slot * next;

    i.2 = (unsigned int) i;
    D.8908 = i.2 * 4;
    D.8909 = table + D.8908;
    s = *D.8909;
    goto <D.8586>;
    <D.8585>:
    {
      guint hashcode;

      D.8910 = hash->hash_func;
      D.8911 = s->key;
      D.8912 = D.8910 (D.8911);
      D.8899 = hash->table_size;
      D.8913 = (unsigned int) D.8899;
      hashcode = D.8912 % D.8913;
      next = s->next;
      D.8914 = hash->table;
      D.8915 = hashcode * 4;
      D.8916 = D.8914 + D.8915;
      D.8917 = *D.8916;
      s->next = D.8917;
      D.8914 = hash->table;
      D.8915 = hashcode * 4;
      D.8916 = D.8914 + D.8915;
      *D.8916 = s;
    }
    s = next;
    <D.8586>:
    if (s != 0B) goto <D.8585>; else goto <D.8587>;
    <D.8587>:
  }
  i = i + 1;
  <D.8589>:
  if (i < current_size) goto <D.8588>; else goto <D.8590>;
  <D.8590>:
  monoeg_g_free (table);
}


monoeg_g_hash_table_get_keys (struct GHashTable * hash)
{
  void * key.3;
  int D.8919;
  struct GList * D.8920;
  struct GHashTableIter iter;
  struct GList * rv;
  void * key;

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.8614>;
      <D.8613>:
      key.3 = key;
      rv = monoeg_g_list_prepend (rv, key.3);
      <D.8614>:
      D.8919 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.8919 != 0) goto <D.8613>; else goto <D.8615>;
      <D.8615>:
      D.8920 = monoeg_g_list_reverse (rv);
      return D.8920;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


monoeg_g_hash_table_get_values (struct GHashTable * hash)
{
  void * value.4;
  int D.8924;
  struct GList * D.8925;
  struct GHashTableIter iter;
  struct GList * rv;
  void * value;

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.8623>;
      <D.8622>:
      value.4 = value;
      rv = monoeg_g_list_prepend (rv, value.4);
      <D.8623>:
      D.8924 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.8924 != 0) goto <D.8622>; else goto <D.8624>;
      <D.8624>:
      D.8925 = monoeg_g_list_reverse (rv);
      return D.8925;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.8930;
  int D.8931;

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


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

  try
    {
      D.8933 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.8933 != 0) goto <D.8934>; else goto <D.8935>;
      <D.8934>:
      D.8936 = value;
      return D.8936;
      <D.8935>:
      D.8936 = 0B;
      return D.8936;
    }
  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.8941;
  guint (*<T1895>) (const void *) D.8942;
  unsigned int D.8943;
  int D.8944;
  unsigned int D.8945;
  struct Slot * * D.8946;
  unsigned int D.8947;
  struct Slot * * D.8948;
  void * D.8949;
  int D.8950;
  void * D.8957;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.8939>; else goto <D.8940>;
  <D.8939>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.8941 = 0;
  return D.8941;
  <D.8940>:
  equal = hash->key_equal_func;
  D.8942 = hash->hash_func;
  D.8943 = D.8942 (key);
  D.8944 = hash->table_size;
  D.8945 = (unsigned int) D.8944;
  hashcode = D.8943 % D.8945;
  D.8946 = hash->table;
  D.8947 = hashcode * 4;
  D.8948 = D.8946 + D.8947;
  s = *D.8948;
  goto <D.8644>;
  <D.8643>:
  D.8949 = s->key;
  D.8950 = equal (D.8949, key);
  if (D.8950 != 0) goto <D.8951>; else goto <D.8952>;
  <D.8951>:
  if (orig_key != 0B) goto <D.8953>; else goto <D.8954>;
  <D.8953>:
  D.8949 = s->key;
  *orig_key = D.8949;
  <D.8954>:
  if (value != 0B) goto <D.8955>; else goto <D.8956>;
  <D.8955>:
  D.8957 = s->value;
  *value = D.8957;
  <D.8956>:
  D.8941 = 1;
  return D.8941;
  <D.8952>:
  s = s->next;
  <D.8644>:
  if (s != 0B) goto <D.8643>; else goto <D.8645>;
  <D.8645>:
  D.8941 = 0;
  return D.8941;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.8963;
  unsigned int i.5;
  unsigned int D.8965;
  struct Slot * * D.8966;
  void * D.8967;
  void * D.8968;
  int D.8969;
  int i;

  if (hash == 0B) goto <D.8959>; else goto <D.8960>;
  <D.8959>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.8960>:
  if (func == 0B) goto <D.8961>; else goto <D.8962>;
  <D.8961>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.8962>:
  i = 0;
  goto <D.8657>;
  <D.8656>:
  {
    struct Slot * s;

    D.8963 = hash->table;
    i.5 = (unsigned int) i;
    D.8965 = i.5 * 4;
    D.8966 = D.8963 + D.8965;
    s = *D.8966;
    goto <D.8654>;
    <D.8653>:
    D.8967 = s->key;
    D.8968 = s->value;
    func (D.8967, D.8968, user_data);
    s = s->next;
    <D.8654>:
    if (s != 0B) goto <D.8653>; else goto <D.8655>;
    <D.8655>:
  }
  i = i + 1;
  <D.8657>:
  D.8969 = hash->table_size;
  if (D.8969 > i) goto <D.8656>; else goto <D.8658>;
  <D.8658>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.8973;
  struct Slot * * D.8976;
  unsigned int i.6;
  unsigned int D.8978;
  struct Slot * * D.8979;
  void * D.8980;
  void * D.8981;
  int D.8982;
  int D.8985;
  int i;

  if (hash == 0B) goto <D.8971>; else goto <D.8972>;
  <D.8971>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.8973 = 0B;
  return D.8973;
  <D.8972>:
  if (predicate == 0B) goto <D.8974>; else goto <D.8975>;
  <D.8974>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.8973 = 0B;
  return D.8973;
  <D.8975>:
  i = 0;
  goto <D.8670>;
  <D.8669>:
  {
    struct Slot * s;

    D.8976 = hash->table;
    i.6 = (unsigned int) i;
    D.8978 = i.6 * 4;
    D.8979 = D.8976 + D.8978;
    s = *D.8979;
    goto <D.8667>;
    <D.8666>:
    D.8980 = s->key;
    D.8981 = s->value;
    D.8982 = predicate (D.8980, D.8981, user_data);
    if (D.8982 != 0) goto <D.8983>; else goto <D.8984>;
    <D.8983>:
    D.8973 = s->value;
    return D.8973;
    <D.8984>:
    s = s->next;
    <D.8667>:
    if (s != 0B) goto <D.8666>; else goto <D.8668>;
    <D.8668>:
  }
  i = i + 1;
  <D.8670>:
  D.8985 = hash->table_size;
  if (D.8985 > i) goto <D.8669>; else goto <D.8671>;
  <D.8671>:
  D.8973 = 0B;
  return D.8973;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.8989;
  unsigned int i.7;
  unsigned int D.8991;
  struct Slot * * D.8992;
  void * D.8993;
  struct Slot * D.8994;
  int D.8995;
  int i;

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

    goto <D.8678>;
    <D.8677>:
    D.8989 = hash->table;
    i.7 = (unsigned int) i;
    D.8991 = i.7 * 4;
    D.8992 = D.8989 + D.8991;
    s = *D.8992;
    D.8993 = s->key;
    monoeg_g_hash_table_remove (hash, D.8993);
    <D.8678>:
    D.8989 = hash->table;
    i.7 = (unsigned int) i;
    D.8991 = i.7 * 4;
    D.8992 = D.8989 + D.8991;
    D.8994 = *D.8992;
    if (D.8994 != 0B) goto <D.8677>; else goto <D.8679>;
    <D.8679>:
  }
  i = i + 1;
  <D.8681>:
  D.8995 = hash->table_size;
  if (D.8995 > i) goto <D.8680>; else goto <D.8682>;
  <D.8682>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.8999;
  guint (*<T1895>) (const void *) D.9000;
  unsigned int D.9001;
  int D.9002;
  unsigned int D.9003;
  struct Slot * * D.9004;
  unsigned int D.9005;
  struct Slot * * D.9006;
  void * D.9007;
  int D.9008;
  void (*<T17e9>) (void *) D.9011;
  void (*<T17e9>) (void *) D.9014;
  void * D.9017;
  struct Slot * D.9020;
  int D.9022;
  int D.9023;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.8997>; else goto <D.8998>;
  <D.8997>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.8999 = 0;
  return D.8999;
  <D.8998>:
  equal = hash->key_equal_func;
  D.9000 = hash->hash_func;
  D.9001 = D.9000 (key);
  D.9002 = hash->table_size;
  D.9003 = (unsigned int) D.9002;
  hashcode = D.9001 % D.9003;
  last = 0B;
  D.9004 = hash->table;
  D.9005 = hashcode * 4;
  D.9006 = D.9004 + D.9005;
  s = *D.9006;
  goto <D.8692>;
  <D.8691>:
  D.9007 = s->key;
  D.9008 = equal (D.9007, key);
  if (D.9008 != 0) goto <D.9009>; else goto <D.9010>;
  <D.9009>:
  D.9011 = hash->key_destroy_func;
  if (D.9011 != 0B) goto <D.9012>; else goto <D.9013>;
  <D.9012>:
  D.9011 = hash->key_destroy_func;
  D.9007 = s->key;
  D.9011 (D.9007);
  <D.9013>:
  D.9014 = hash->value_destroy_func;
  if (D.9014 != 0B) goto <D.9015>; else goto <D.9016>;
  <D.9015>:
  D.9014 = hash->value_destroy_func;
  D.9017 = s->value;
  D.9014 (D.9017);
  <D.9016>:
  if (last == 0B) goto <D.9018>; else goto <D.9019>;
  <D.9018>:
  D.9004 = hash->table;
  D.9005 = hashcode * 4;
  D.9006 = D.9004 + D.9005;
  D.9020 = s->next;
  *D.9006 = D.9020;
  goto <D.9021>;
  <D.9019>:
  D.9020 = s->next;
  last->next = D.9020;
  <D.9021>:
  monoeg_g_free (s);
  D.9022 = hash->in_use;
  D.9023 = D.9022 + -1;
  hash->in_use = D.9023;
  D.8999 = 1;
  return D.8999;
  <D.9010>:
  last = s;
  s = s->next;
  <D.8692>:
  if (s != 0B) goto <D.8691>; else goto <D.8693>;
  <D.8693>:
  D.8999 = 0;
  return D.8999;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.9027;
  struct Slot * * D.9030;
  unsigned int i.8;
  unsigned int D.9032;
  struct Slot * * D.9033;
  void * D.9034;
  void * D.9035;
  int D.9036;
  void (*<T17e9>) (void *) D.9039;
  void (*<T17e9>) (void *) D.9042;
  struct Slot * D.9047;
  int D.9049;
  int D.9050;
  int D.9052;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.9025>; else goto <D.9026>;
  <D.9025>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.9027 = 0;
  return D.9027;
  <D.9026>:
  if (func == 0B) goto <D.9028>; else goto <D.9029>;
  <D.9028>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.9027 = 0;
  return D.9027;
  <D.9029>:
  i = 0;
  goto <D.8708>;
  <D.8707>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.9030 = hash->table;
    i.8 = (unsigned int) i;
    D.9032 = i.8 * 4;
    D.9033 = D.9030 + D.9032;
    s = *D.9033;
    goto <D.8705>;
    <D.8704>:
    D.9034 = s->key;
    D.9035 = s->value;
    D.9036 = func (D.9034, D.9035, user_data);
    if (D.9036 != 0) goto <D.9037>; else goto <D.9038>;
    <D.9037>:
    {
      struct Slot * n;

      D.9039 = hash->key_destroy_func;
      if (D.9039 != 0B) goto <D.9040>; else goto <D.9041>;
      <D.9040>:
      D.9039 = hash->key_destroy_func;
      D.9034 = s->key;
      D.9039 (D.9034);
      <D.9041>:
      D.9042 = hash->value_destroy_func;
      if (D.9042 != 0B) goto <D.9043>; else goto <D.9044>;
      <D.9043>:
      D.9042 = hash->value_destroy_func;
      D.9035 = s->value;
      D.9042 (D.9035);
      <D.9044>:
      if (last == 0B) goto <D.9045>; else goto <D.9046>;
      <D.9045>:
      D.9030 = hash->table;
      i.8 = (unsigned int) i;
      D.9032 = i.8 * 4;
      D.9033 = D.9030 + D.9032;
      D.9047 = s->next;
      *D.9033 = D.9047;
      n = s->next;
      goto <D.9048>;
      <D.9046>:
      D.9047 = s->next;
      last->next = D.9047;
      n = last->next;
      <D.9048>:
      monoeg_g_free (s);
      D.9049 = hash->in_use;
      D.9050 = D.9049 + -1;
      hash->in_use = D.9050;
      count = count + 1;
      s = n;
    }
    goto <D.9051>;
    <D.9038>:
    last = s;
    s = s->next;
    <D.9051>:
    <D.8705>:
    if (s != 0B) goto <D.8704>; else goto <D.8706>;
    <D.8706>:
  }
  i = i + 1;
  <D.8708>:
  D.9052 = hash->table_size;
  if (D.9052 > i) goto <D.8707>; else goto <D.8709>;
  <D.8709>:
  if (count > 0) goto <D.9053>; else goto <D.9054>;
  <D.9053>:
  rehash (hash);
  <D.9054>:
  D.9027 = (guint) count;
  return D.9027;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.9058;
  guint (*<T1895>) (const void *) D.9059;
  unsigned int D.9060;
  int D.9061;
  unsigned int D.9062;
  struct Slot * * D.9063;
  unsigned int D.9064;
  struct Slot * * D.9065;
  void * D.9066;
  int D.9067;
  struct Slot * D.9072;
  int D.9074;
  int D.9075;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.9056>; else goto <D.9057>;
  <D.9056>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.9058 = 0;
  return D.9058;
  <D.9057>:
  equal = hash->key_equal_func;
  D.9059 = hash->hash_func;
  D.9060 = D.9059 (key);
  D.9061 = hash->table_size;
  D.9062 = (unsigned int) D.9061;
  hashcode = D.9060 % D.9062;
  last = 0B;
  D.9063 = hash->table;
  D.9064 = hashcode * 4;
  D.9065 = D.9063 + D.9064;
  s = *D.9065;
  goto <D.8719>;
  <D.8718>:
  D.9066 = s->key;
  D.9067 = equal (D.9066, key);
  if (D.9067 != 0) goto <D.9068>; else goto <D.9069>;
  <D.9068>:
  if (last == 0B) goto <D.9070>; else goto <D.9071>;
  <D.9070>:
  D.9063 = hash->table;
  D.9064 = hashcode * 4;
  D.9065 = D.9063 + D.9064;
  D.9072 = s->next;
  *D.9065 = D.9072;
  goto <D.9073>;
  <D.9071>:
  D.9072 = s->next;
  last->next = D.9072;
  <D.9073>:
  monoeg_g_free (s);
  D.9074 = hash->in_use;
  D.9075 = D.9074 + -1;
  hash->in_use = D.9075;
  D.9058 = 1;
  return D.9058;
  <D.9069>:
  last = s;
  s = s->next;
  <D.8719>:
  if (s != 0B) goto <D.8718>; else goto <D.8720>;
  <D.8720>:
  D.9058 = 0;
  return D.9058;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.9079;
  struct Slot * * D.9082;
  unsigned int i.9;
  unsigned int D.9084;
  struct Slot * * D.9085;
  void * D.9086;
  void * D.9087;
  int D.9088;
  struct Slot * D.9093;
  int D.9095;
  int D.9096;
  int D.9098;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.9077>; else goto <D.9078>;
  <D.9077>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.9079 = 0;
  return D.9079;
  <D.9078>:
  if (func == 0B) goto <D.9080>; else goto <D.9081>;
  <D.9080>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.9079 = 0;
  return D.9079;
  <D.9081>:
  i = 0;
  goto <D.8735>;
  <D.8734>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.9082 = hash->table;
    i.9 = (unsigned int) i;
    D.9084 = i.9 * 4;
    D.9085 = D.9082 + D.9084;
    s = *D.9085;
    goto <D.8732>;
    <D.8731>:
    D.9086 = s->key;
    D.9087 = s->value;
    D.9088 = func (D.9086, D.9087, user_data);
    if (D.9088 != 0) goto <D.9089>; else goto <D.9090>;
    <D.9089>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.9091>; else goto <D.9092>;
      <D.9091>:
      D.9082 = hash->table;
      i.9 = (unsigned int) i;
      D.9084 = i.9 * 4;
      D.9085 = D.9082 + D.9084;
      D.9093 = s->next;
      *D.9085 = D.9093;
      n = s->next;
      goto <D.9094>;
      <D.9092>:
      D.9093 = s->next;
      last->next = D.9093;
      n = last->next;
      <D.9094>:
      monoeg_g_free (s);
      D.9095 = hash->in_use;
      D.9096 = D.9095 + -1;
      hash->in_use = D.9096;
      count = count + 1;
      s = n;
    }
    goto <D.9097>;
    <D.9090>:
    last = s;
    s = s->next;
    <D.9097>:
    <D.8732>:
    if (s != 0B) goto <D.8731>; else goto <D.8733>;
    <D.8733>:
  }
  i = i + 1;
  <D.8735>:
  D.9098 = hash->table_size;
  if (D.9098 > i) goto <D.8734>; else goto <D.8736>;
  <D.8736>:
  if (count > 0) goto <D.9099>; else goto <D.9100>;
  <D.9099>:
  rehash (hash);
  <D.9100>:
  D.9079 = (guint) count;
  return D.9079;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.9104;
  unsigned int i.10;
  unsigned int D.9106;
  struct Slot * * D.9107;
  void (*<T17e9>) (void *) D.9108;
  void * D.9111;
  void (*<T17e9>) (void *) D.9112;
  void * D.9115;
  int D.9116;
  int i;

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

    D.9104 = hash->table;
    i.10 = (unsigned int) i;
    D.9106 = i.10 * 4;
    D.9107 = D.9104 + D.9106;
    s = *D.9107;
    goto <D.8744>;
    <D.8743>:
    next = s->next;
    D.9108 = hash->key_destroy_func;
    if (D.9108 != 0B) goto <D.9109>; else goto <D.9110>;
    <D.9109>:
    D.9108 = hash->key_destroy_func;
    D.9111 = s->key;
    D.9108 (D.9111);
    <D.9110>:
    D.9112 = hash->value_destroy_func;
    if (D.9112 != 0B) goto <D.9113>; else goto <D.9114>;
    <D.9113>:
    D.9112 = hash->value_destroy_func;
    D.9115 = s->value;
    D.9112 (D.9115);
    <D.9114>:
    monoeg_g_free (s);
    s = next;
    <D.8744>:
    if (s != 0B) goto <D.8743>; else goto <D.8745>;
    <D.8745>:
  }
  i = i + 1;
  <D.8747>:
  D.9116 = hash->table_size;
  if (D.9116 > i) goto <D.8746>; else goto <D.8748>;
  <D.8748>:
  D.9104 = hash->table;
  monoeg_g_free (D.9104);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.9118;
  unsigned int i.11;
  unsigned int D.9120;
  struct Slot * * D.9121;
  int D.9124;
  int D.9125;
  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.8761>;
  <D.8760>:
  chain_size = 0;
  D.9118 = table->table;
  i.11 = (unsigned int) i;
  D.9120 = i.11 * 4;
  D.9121 = D.9118 + D.9120;
  node = *D.9121;
  goto <D.8758>;
  <D.8757>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.8758>:
  if (node != 0B) goto <D.8757>; else goto <D.8759>;
  <D.8759>:
  if (chain_size > max_chain_size) goto <D.9122>; else goto <D.9123>;
  <D.9122>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.9123>:
  i = i + 1;
  <D.8761>:
  D.9124 = table->table_size;
  if (D.9124 > i) goto <D.8760>; else goto <D.8762>;
  <D.8762>:
  D.9125 = table->in_use;
  D.9124 = table->table_size;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.9125, D.9124, max_chain_size, max_chain_index);
}


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

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


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.9130;
  int D.9135;
  void * D.9137;
  unsigned int D.9138;

  D.9130 = __builtin_constant_p (__len);
  if (D.9130 != 0) goto <D.9131>; else goto <D.9132>;
  <D.9131>:
  if (__len == 0) goto <D.9133>; else goto <D.9134>;
  <D.9133>:
  D.9135 = __builtin_constant_p (__ch);
  if (D.9135 == 0) goto <D.9128>; else goto <D.9136>;
  <D.9136>:
  if (__ch != 0) goto <D.9128>; else goto <D.9129>;
  <D.9128>:
  __warn_memset_zero_len ();
  D.9137 = __dest;
  return D.9137;
  <D.9129>:
  <D.9134>:
  <D.9132>:
  D.9138 = __builtin_object_size (__dest, 0);
  D.9137 = __builtin___memset_chk (__dest, __ch, __len, D.9138);
  return D.9137;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.9140;
  _Bool D.9141;
  long int D.9142;
  long int D.9143;
  struct Slot * D.9148;
  int D.9151;
  int D.9152;
  gboolean D.9155;
  struct Slot * * D.9156;
  unsigned int D.9157;
  unsigned int D.9158;
  struct Slot * * D.9159;
  struct Slot * D.9160;
  void * D.9164;
  void * D.9167;
  struct Slot * D.9168;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.9140 = iter->slot_index;
  D.9141 = D.9140 == -2;
  D.9142 = (long int) D.9141;
  D.9143 = __builtin_expect (D.9142, 0);
  if (D.9143 != 0) goto <D.9144>; else goto <D.9145>;
  <D.9144>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.9145>:
  if (0 != 0) goto <D.9146>; else goto <D.9147>;
  <D.9146>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.9147>:
  D.9148 = iter->slot;
  if (D.9148 == 0B) goto <D.9149>; else goto <D.9150>;
  <D.9149>:
  <D.8776>:
  D.9140 = iter->slot_index;
  D.9151 = D.9140 + 1;
  iter->slot_index = D.9151;
  D.9140 = iter->slot_index;
  D.9152 = hash->table_size;
  if (D.9140 >= D.9152) goto <D.9153>; else goto <D.9154>;
  <D.9153>:
  iter->slot_index = -2;
  D.9155 = 0;
  return D.9155;
  <D.9154>:
  D.9156 = hash->table;
  D.9140 = iter->slot_index;
  D.9157 = (unsigned int) D.9140;
  D.9158 = D.9157 * 4;
  D.9159 = D.9156 + D.9158;
  D.9160 = *D.9159;
  if (D.9160 != 0B) goto <D.8775>; else goto <D.9161>;
  <D.9161>:
  goto <D.8776>;
  <D.8775>:
  D.9156 = hash->table;
  D.9140 = iter->slot_index;
  D.9157 = (unsigned int) D.9140;
  D.9158 = D.9157 * 4;
  D.9159 = D.9156 + D.9158;
  D.9160 = *D.9159;
  iter->slot = D.9160;
  <D.9150>:
  if (key != 0B) goto <D.9162>; else goto <D.9163>;
  <D.9162>:
  D.9148 = iter->slot;
  D.9164 = D.9148->key;
  *key = D.9164;
  <D.9163>:
  if (value != 0B) goto <D.9165>; else goto <D.9166>;
  <D.9165>:
  D.9148 = iter->slot;
  D.9167 = D.9148->value;
  *value = D.9167;
  <D.9166>:
  D.9148 = iter->slot;
  D.9168 = D.9148->next;
  iter->slot = D.9168;
  D.9155 = 1;
  return D.9155;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.9170;
  _Bool D.9171;

  D.9171 = v1 == v2;
  D.9170 = (gboolean) D.9171;
  return D.9170;
}


monoeg_g_direct_hash (const void * v1)
{
  guint D.9173;

  D.9173 = (guint) v1;
  return D.9173;
}


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.9175;
  int D.9176;
  int D.9177;
  _Bool D.9178;

  D.9176 = MEM[(gint *)v1];
  D.9177 = MEM[(gint *)v2];
  D.9178 = D.9176 == D.9177;
  D.9175 = (gboolean) D.9178;
  return D.9175;
}


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

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


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.9182;
  int D.8803;
  _Bool D.9183;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.8803 = __builtin_strcmp (v1, v2);
  }
  D.9183 = D.8803 == 0;
  D.9182 = (gboolean) D.9183;
  return D.9182;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.9185;
  char D.9186;
  unsigned int D.9187;
  unsigned int D.9188;
  char * p.12;
  char D.9190;
  guint D.9191;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.8810>;
  <D.8809>:
  D.9185 = hash << 5;
  D.9186 = *p;
  D.9187 = (unsigned int) D.9186;
  D.9188 = D.9187 + hash;
  hash = D.9185 - D.9188;
  <D.8810>:
  p.12 = p;
  p = p.12 + 1;
  D.9190 = *p.12;
  if (D.9190 != 0) goto <D.8809>; else goto <D.8811>;
  <D.8811>:
  D.9191 = hash;
  return D.9191;
}