monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.5974;
  guint D.5977;
  unsigned int i.0;
  int x.1;
  int D.5980;
  int i;

  i = 0;
  goto <D.5723>;
  <D.5722>:
  D.5974 = prime_tbl[i];
  if (D.5974 >= x) goto <D.5975>; else goto <D.5976>;
  <D.5975>:
  D.5977 = prime_tbl[i];
  return D.5977;
  <D.5976>:
  i = i + 1;
  <D.5723>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.5722>; else goto <D.5724>;
  <D.5724>:
  x.1 = (int) x;
  D.5980 = calc_prime (x.1);
  D.5977 = (guint) D.5980;
  return D.5977;
}


calc_prime (int x)
{
  int D.5982;
  int D.5983;
  int D.5986;
  int i;

  D.5982 = x & -2;
  i = D.5982 + -1;
  goto <D.5716>;
  <D.5715>:
  D.5983 = test_prime (i);
  if (D.5983 != 0) goto <D.5984>; else goto <D.5985>;
  <D.5984>:
  D.5986 = i;
  return D.5986;
  <D.5985>:
  i = i + 2;
  <D.5716>:
  if (i != 2147483647) goto <D.5715>; else goto <D.5717>;
  <D.5717>:
  D.5986 = x;
  return D.5986;
}


test_prime (int x)
{
  int D.5988;
  int D.5991;
  gboolean D.5994;
  double D.5995;
  double D.5996;
  int D.5997;
  _Bool D.5998;

  D.5988 = x & 1;
  if (D.5988 != 0) goto <D.5989>; else goto <D.5990>;
  <D.5989>:
  {
    int n;

    n = 3;
    goto <D.5709>;
    <D.5708>:
    D.5991 = x % n;
    if (D.5991 == 0) goto <D.5992>; else goto <D.5993>;
    <D.5992>:
    D.5994 = 0;
    return D.5994;
    <D.5993>:
    n = n + 2;
    <D.5709>:
    D.5995 = (double) x;
    D.5996 = sqrt (D.5995);
    D.5997 = (int) D.5996;
    if (D.5997 > n) goto <D.5708>; else goto <D.5710>;
    <D.5710>:
    D.5994 = 1;
    return D.5994;
  }
  <D.5990>:
  D.5998 = x == 2;
  D.5994 = (gboolean) D.5998;
  return D.5994;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.6004;
  int D.6005;
  int D.6006;
  unsigned int D.6007;
  unsigned int D.6008;
  void * D.6009;
  struct GHashTable * D.6010;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.6000>; else goto <D.6001>;
  <D.6000>:
  hash_func = monoeg_g_direct_hash;
  <D.6001>:
  if (key_equal_func == 0B) goto <D.6002>; else goto <D.6003>;
  <D.6002>:
  key_equal_func = monoeg_g_direct_equal;
  <D.6003>:
  hash = monoeg_malloc0 (36);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.6004 = monoeg_g_spaced_primes_closest (1);
  D.6005 = (int) D.6004;
  hash->table_size = D.6005;
  D.6006 = hash->table_size;
  D.6007 = (unsigned int) D.6006;
  D.6008 = D.6007 * 4;
  D.6009 = monoeg_malloc0 (D.6008);
  hash->table = D.6009;
  D.6006 = hash->table_size;
  hash->last_rehash = D.6006;
  D.6010 = hash;
  return D.6010;
}


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

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


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.6018;
  int D.6019;
  guint (*<Td94>) (const void *) D.6022;
  unsigned int D.6023;
  int D.6024;
  unsigned int D.6025;
  struct Slot * * D.6026;
  unsigned int D.6027;
  struct Slot * * D.6028;
  void * D.6029;
  int D.6030;
  void (*<Tce8>) (void *) D.6035;
  void (*<Tce8>) (void *) D.6038;
  void * D.6041;
  struct Slot * D.6042;
  int D.6043;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.6016>; else goto <D.6017>;
  <D.6016>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.6017>:
  equal = hash->key_equal_func;
  D.6018 = hash->in_use;
  D.6019 = hash->threshold;
  if (D.6018 >= D.6019) goto <D.6020>; else goto <D.6021>;
  <D.6020>:
  rehash (hash);
  <D.6021>:
  D.6022 = hash->hash_func;
  D.6023 = D.6022 (key);
  D.6024 = hash->table_size;
  D.6025 = (unsigned int) D.6024;
  hashcode = D.6023 % D.6025;
  D.6026 = hash->table;
  D.6027 = hashcode * 4;
  D.6028 = D.6026 + D.6027;
  s = *D.6028;
  goto <D.5766>;
  <D.5765>:
  D.6029 = s->key;
  D.6030 = equal (D.6029, key);
  if (D.6030 != 0) goto <D.6031>; else goto <D.6032>;
  <D.6031>:
  if (replace != 0) goto <D.6033>; else goto <D.6034>;
  <D.6033>:
  D.6035 = hash->key_destroy_func;
  if (D.6035 != 0B) goto <D.6036>; else goto <D.6037>;
  <D.6036>:
  D.6035 = hash->key_destroy_func;
  D.6029 = s->key;
  D.6035 (D.6029);
  <D.6037>:
  s->key = key;
  <D.6034>:
  D.6038 = hash->value_destroy_func;
  if (D.6038 != 0B) goto <D.6039>; else goto <D.6040>;
  <D.6039>:
  D.6038 = hash->value_destroy_func;
  D.6041 = s->value;
  D.6038 (D.6041);
  <D.6040>:
  s->value = value;
  return;
  <D.6032>:
  s = s->next;
  <D.5766>:
  if (s != 0B) goto <D.5765>; else goto <D.5767>;
  <D.5767>:
  s = monoeg_malloc (12);
  s->key = key;
  s->value = value;
  D.6026 = hash->table;
  D.6027 = hashcode * 4;
  D.6028 = D.6026 + D.6027;
  D.6042 = *D.6028;
  s->next = D.6042;
  D.6026 = hash->table;
  D.6027 = hashcode * 4;
  D.6028 = D.6026 + D.6027;
  *D.6028 = s;
  D.6018 = hash->in_use;
  D.6043 = D.6018 + 1;
  hash->in_use = D.6043;
}


rehash (struct GHashTable * hash)
{
  int D.6045;
  int D.6046;
  int D.6047;
  double D.6048;
  double D.6049;
  int D.6050;
  int D.6051;
  double D.6052;
  _Bool D.6053;
  _Bool D.6054;
  int diff;

  D.6045 = hash->last_rehash;
  D.6046 = hash->in_use;
  D.6047 = D.6045 - D.6046;
  diff = ABS_EXPR <D.6047>;
  D.6048 = (double) diff;
  D.6049 = D.6048 * 7.5e-1;
  D.6050 = hash->table_size;
  D.6051 = D.6050 * 2;
  D.6052 = (double) D.6051;
  D.6053 = D.6049 > D.6052;
  D.6054 = ~D.6053;
  if (D.6054 != 0) goto <D.6055>; else goto <D.6056>;
  <D.6055>:
  return;
  <D.6056>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.6058;
  int D.6059;
  unsigned int D.6060;
  unsigned int D.6061;
  int D.6062;
  unsigned int D.6063;
  unsigned int D.6064;
  void * D.6065;
  unsigned int i.2;
  unsigned int D.6067;
  struct Slot * * D.6068;
  guint (*<Td94>) (const void *) D.6069;
  void * D.6070;
  unsigned int D.6071;
  unsigned int D.6072;
  struct Slot * * D.6073;
  unsigned int D.6074;
  struct Slot * * D.6075;
  struct Slot * D.6076;
  int current_size;
  int i;
  struct Slot * * table;

  D.6058 = hash->table_size;
  hash->last_rehash = D.6058;
  current_size = hash->table_size;
  D.6059 = hash->in_use;
  D.6060 = (unsigned int) D.6059;
  D.6061 = monoeg_g_spaced_primes_closest (D.6060);
  D.6062 = (int) D.6061;
  hash->table_size = D.6062;
  table = hash->table;
  D.6058 = hash->table_size;
  D.6063 = (unsigned int) D.6058;
  D.6064 = D.6063 * 4;
  D.6065 = monoeg_malloc0 (D.6064);
  hash->table = D.6065;
  i = 0;
  goto <D.5750>;
  <D.5749>:
  {
    struct Slot * s;
    struct Slot * next;

    i.2 = (unsigned int) i;
    D.6067 = i.2 * 4;
    D.6068 = table + D.6067;
    s = *D.6068;
    goto <D.5747>;
    <D.5746>:
    {
      guint hashcode;

      D.6069 = hash->hash_func;
      D.6070 = s->key;
      D.6071 = D.6069 (D.6070);
      D.6058 = hash->table_size;
      D.6072 = (unsigned int) D.6058;
      hashcode = D.6071 % D.6072;
      next = s->next;
      D.6073 = hash->table;
      D.6074 = hashcode * 4;
      D.6075 = D.6073 + D.6074;
      D.6076 = *D.6075;
      s->next = D.6076;
      D.6073 = hash->table;
      D.6074 = hashcode * 4;
      D.6075 = D.6073 + D.6074;
      *D.6075 = s;
    }
    s = next;
    <D.5747>:
    if (s != 0B) goto <D.5746>; else goto <D.5748>;
    <D.5748>:
  }
  i = i + 1;
  <D.5750>:
  if (i < current_size) goto <D.5749>; else goto <D.5751>;
  <D.5751>:
  monoeg_g_free (table);
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.5775>;
      <D.5774>:
      key.3 = key;
      rv = monoeg_g_list_prepend (rv, key.3);
      <D.5775>:
      D.6078 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.6078 != 0) goto <D.5774>; else goto <D.5776>;
      <D.5776>:
      D.6079 = monoeg_g_list_reverse (rv);
      return D.6079;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.5784>;
      <D.5783>:
      value.4 = value;
      rv = monoeg_g_list_prepend (rv, value.4);
      <D.5784>:
      D.6083 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.6083 != 0) goto <D.5783>; else goto <D.5785>;
      <D.5785>:
      D.6084 = monoeg_g_list_reverse (rv);
      return D.6084;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.6089;
  int D.6090;

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


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

  try
    {
      D.6092 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.6092 != 0) goto <D.6093>; else goto <D.6094>;
      <D.6093>:
      D.6095 = value;
      return D.6095;
      <D.6094>:
      D.6095 = 0B;
      return D.6095;
    }
  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.6100;
  guint (*<Td94>) (const void *) D.6101;
  unsigned int D.6102;
  int D.6103;
  unsigned int D.6104;
  struct Slot * * D.6105;
  unsigned int D.6106;
  struct Slot * * D.6107;
  void * D.6108;
  int D.6109;
  void * D.6116;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.6098>; else goto <D.6099>;
  <D.6098>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.6100 = 0;
  return D.6100;
  <D.6099>:
  equal = hash->key_equal_func;
  D.6101 = hash->hash_func;
  D.6102 = D.6101 (key);
  D.6103 = hash->table_size;
  D.6104 = (unsigned int) D.6103;
  hashcode = D.6102 % D.6104;
  D.6105 = hash->table;
  D.6106 = hashcode * 4;
  D.6107 = D.6105 + D.6106;
  s = *D.6107;
  goto <D.5805>;
  <D.5804>:
  D.6108 = s->key;
  D.6109 = equal (D.6108, key);
  if (D.6109 != 0) goto <D.6110>; else goto <D.6111>;
  <D.6110>:
  if (orig_key != 0B) goto <D.6112>; else goto <D.6113>;
  <D.6112>:
  D.6108 = s->key;
  *orig_key = D.6108;
  <D.6113>:
  if (value != 0B) goto <D.6114>; else goto <D.6115>;
  <D.6114>:
  D.6116 = s->value;
  *value = D.6116;
  <D.6115>:
  D.6100 = 1;
  return D.6100;
  <D.6111>:
  s = s->next;
  <D.5805>:
  if (s != 0B) goto <D.5804>; else goto <D.5806>;
  <D.5806>:
  D.6100 = 0;
  return D.6100;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.6122;
  unsigned int i.5;
  unsigned int D.6124;
  struct Slot * * D.6125;
  void * D.6126;
  void * D.6127;
  int D.6128;
  int i;

  if (hash == 0B) goto <D.6118>; else goto <D.6119>;
  <D.6118>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.6119>:
  if (func == 0B) goto <D.6120>; else goto <D.6121>;
  <D.6120>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.6121>:
  i = 0;
  goto <D.5818>;
  <D.5817>:
  {
    struct Slot * s;

    D.6122 = hash->table;
    i.5 = (unsigned int) i;
    D.6124 = i.5 * 4;
    D.6125 = D.6122 + D.6124;
    s = *D.6125;
    goto <D.5815>;
    <D.5814>:
    D.6126 = s->key;
    D.6127 = s->value;
    func (D.6126, D.6127, user_data);
    s = s->next;
    <D.5815>:
    if (s != 0B) goto <D.5814>; else goto <D.5816>;
    <D.5816>:
  }
  i = i + 1;
  <D.5818>:
  D.6128 = hash->table_size;
  if (D.6128 > i) goto <D.5817>; else goto <D.5819>;
  <D.5819>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.6132;
  struct Slot * * D.6135;
  unsigned int i.6;
  unsigned int D.6137;
  struct Slot * * D.6138;
  void * D.6139;
  void * D.6140;
  int D.6141;
  int D.6144;
  int i;

  if (hash == 0B) goto <D.6130>; else goto <D.6131>;
  <D.6130>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.6132 = 0B;
  return D.6132;
  <D.6131>:
  if (predicate == 0B) goto <D.6133>; else goto <D.6134>;
  <D.6133>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.6132 = 0B;
  return D.6132;
  <D.6134>:
  i = 0;
  goto <D.5831>;
  <D.5830>:
  {
    struct Slot * s;

    D.6135 = hash->table;
    i.6 = (unsigned int) i;
    D.6137 = i.6 * 4;
    D.6138 = D.6135 + D.6137;
    s = *D.6138;
    goto <D.5828>;
    <D.5827>:
    D.6139 = s->key;
    D.6140 = s->value;
    D.6141 = predicate (D.6139, D.6140, user_data);
    if (D.6141 != 0) goto <D.6142>; else goto <D.6143>;
    <D.6142>:
    D.6132 = s->value;
    return D.6132;
    <D.6143>:
    s = s->next;
    <D.5828>:
    if (s != 0B) goto <D.5827>; else goto <D.5829>;
    <D.5829>:
  }
  i = i + 1;
  <D.5831>:
  D.6144 = hash->table_size;
  if (D.6144 > i) goto <D.5830>; else goto <D.5832>;
  <D.5832>:
  D.6132 = 0B;
  return D.6132;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.6148;
  unsigned int i.7;
  unsigned int D.6150;
  struct Slot * * D.6151;
  void * D.6152;
  struct Slot * D.6153;
  int D.6154;
  int i;

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

    goto <D.5839>;
    <D.5838>:
    D.6148 = hash->table;
    i.7 = (unsigned int) i;
    D.6150 = i.7 * 4;
    D.6151 = D.6148 + D.6150;
    s = *D.6151;
    D.6152 = s->key;
    monoeg_g_hash_table_remove (hash, D.6152);
    <D.5839>:
    D.6148 = hash->table;
    i.7 = (unsigned int) i;
    D.6150 = i.7 * 4;
    D.6151 = D.6148 + D.6150;
    D.6153 = *D.6151;
    if (D.6153 != 0B) goto <D.5838>; else goto <D.5840>;
    <D.5840>:
  }
  i = i + 1;
  <D.5842>:
  D.6154 = hash->table_size;
  if (D.6154 > i) goto <D.5841>; else goto <D.5843>;
  <D.5843>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.6158;
  guint (*<Td94>) (const void *) D.6159;
  unsigned int D.6160;
  int D.6161;
  unsigned int D.6162;
  struct Slot * * D.6163;
  unsigned int D.6164;
  struct Slot * * D.6165;
  void * D.6166;
  int D.6167;
  void (*<Tce8>) (void *) D.6170;
  void (*<Tce8>) (void *) D.6173;
  void * D.6176;
  struct Slot * D.6179;
  int D.6181;
  int D.6182;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6156>; else goto <D.6157>;
  <D.6156>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.6158 = 0;
  return D.6158;
  <D.6157>:
  equal = hash->key_equal_func;
  D.6159 = hash->hash_func;
  D.6160 = D.6159 (key);
  D.6161 = hash->table_size;
  D.6162 = (unsigned int) D.6161;
  hashcode = D.6160 % D.6162;
  last = 0B;
  D.6163 = hash->table;
  D.6164 = hashcode * 4;
  D.6165 = D.6163 + D.6164;
  s = *D.6165;
  goto <D.5853>;
  <D.5852>:
  D.6166 = s->key;
  D.6167 = equal (D.6166, key);
  if (D.6167 != 0) goto <D.6168>; else goto <D.6169>;
  <D.6168>:
  D.6170 = hash->key_destroy_func;
  if (D.6170 != 0B) goto <D.6171>; else goto <D.6172>;
  <D.6171>:
  D.6170 = hash->key_destroy_func;
  D.6166 = s->key;
  D.6170 (D.6166);
  <D.6172>:
  D.6173 = hash->value_destroy_func;
  if (D.6173 != 0B) goto <D.6174>; else goto <D.6175>;
  <D.6174>:
  D.6173 = hash->value_destroy_func;
  D.6176 = s->value;
  D.6173 (D.6176);
  <D.6175>:
  if (last == 0B) goto <D.6177>; else goto <D.6178>;
  <D.6177>:
  D.6163 = hash->table;
  D.6164 = hashcode * 4;
  D.6165 = D.6163 + D.6164;
  D.6179 = s->next;
  *D.6165 = D.6179;
  goto <D.6180>;
  <D.6178>:
  D.6179 = s->next;
  last->next = D.6179;
  <D.6180>:
  monoeg_g_free (s);
  D.6181 = hash->in_use;
  D.6182 = D.6181 + -1;
  hash->in_use = D.6182;
  D.6158 = 1;
  return D.6158;
  <D.6169>:
  last = s;
  s = s->next;
  <D.5853>:
  if (s != 0B) goto <D.5852>; else goto <D.5854>;
  <D.5854>:
  D.6158 = 0;
  return D.6158;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6186;
  struct Slot * * D.6189;
  unsigned int i.8;
  unsigned int D.6191;
  struct Slot * * D.6192;
  void * D.6193;
  void * D.6194;
  int D.6195;
  void (*<Tce8>) (void *) D.6198;
  void (*<Tce8>) (void *) D.6201;
  struct Slot * D.6206;
  int D.6208;
  int D.6209;
  int D.6211;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6184>; else goto <D.6185>;
  <D.6184>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.6186 = 0;
  return D.6186;
  <D.6185>:
  if (func == 0B) goto <D.6187>; else goto <D.6188>;
  <D.6187>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.6186 = 0;
  return D.6186;
  <D.6188>:
  i = 0;
  goto <D.5869>;
  <D.5868>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6189 = hash->table;
    i.8 = (unsigned int) i;
    D.6191 = i.8 * 4;
    D.6192 = D.6189 + D.6191;
    s = *D.6192;
    goto <D.5866>;
    <D.5865>:
    D.6193 = s->key;
    D.6194 = s->value;
    D.6195 = func (D.6193, D.6194, user_data);
    if (D.6195 != 0) goto <D.6196>; else goto <D.6197>;
    <D.6196>:
    {
      struct Slot * n;

      D.6198 = hash->key_destroy_func;
      if (D.6198 != 0B) goto <D.6199>; else goto <D.6200>;
      <D.6199>:
      D.6198 = hash->key_destroy_func;
      D.6193 = s->key;
      D.6198 (D.6193);
      <D.6200>:
      D.6201 = hash->value_destroy_func;
      if (D.6201 != 0B) goto <D.6202>; else goto <D.6203>;
      <D.6202>:
      D.6201 = hash->value_destroy_func;
      D.6194 = s->value;
      D.6201 (D.6194);
      <D.6203>:
      if (last == 0B) goto <D.6204>; else goto <D.6205>;
      <D.6204>:
      D.6189 = hash->table;
      i.8 = (unsigned int) i;
      D.6191 = i.8 * 4;
      D.6192 = D.6189 + D.6191;
      D.6206 = s->next;
      *D.6192 = D.6206;
      n = s->next;
      goto <D.6207>;
      <D.6205>:
      D.6206 = s->next;
      last->next = D.6206;
      n = last->next;
      <D.6207>:
      monoeg_g_free (s);
      D.6208 = hash->in_use;
      D.6209 = D.6208 + -1;
      hash->in_use = D.6209;
      count = count + 1;
      s = n;
    }
    goto <D.6210>;
    <D.6197>:
    last = s;
    s = s->next;
    <D.6210>:
    <D.5866>:
    if (s != 0B) goto <D.5865>; else goto <D.5867>;
    <D.5867>:
  }
  i = i + 1;
  <D.5869>:
  D.6211 = hash->table_size;
  if (D.6211 > i) goto <D.5868>; else goto <D.5870>;
  <D.5870>:
  if (count > 0) goto <D.6212>; else goto <D.6213>;
  <D.6212>:
  rehash (hash);
  <D.6213>:
  D.6186 = (guint) count;
  return D.6186;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.6217;
  guint (*<Td94>) (const void *) D.6218;
  unsigned int D.6219;
  int D.6220;
  unsigned int D.6221;
  struct Slot * * D.6222;
  unsigned int D.6223;
  struct Slot * * D.6224;
  void * D.6225;
  int D.6226;
  struct Slot * D.6231;
  int D.6233;
  int D.6234;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6215>; else goto <D.6216>;
  <D.6215>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.6217 = 0;
  return D.6217;
  <D.6216>:
  equal = hash->key_equal_func;
  D.6218 = hash->hash_func;
  D.6219 = D.6218 (key);
  D.6220 = hash->table_size;
  D.6221 = (unsigned int) D.6220;
  hashcode = D.6219 % D.6221;
  last = 0B;
  D.6222 = hash->table;
  D.6223 = hashcode * 4;
  D.6224 = D.6222 + D.6223;
  s = *D.6224;
  goto <D.5880>;
  <D.5879>:
  D.6225 = s->key;
  D.6226 = equal (D.6225, key);
  if (D.6226 != 0) goto <D.6227>; else goto <D.6228>;
  <D.6227>:
  if (last == 0B) goto <D.6229>; else goto <D.6230>;
  <D.6229>:
  D.6222 = hash->table;
  D.6223 = hashcode * 4;
  D.6224 = D.6222 + D.6223;
  D.6231 = s->next;
  *D.6224 = D.6231;
  goto <D.6232>;
  <D.6230>:
  D.6231 = s->next;
  last->next = D.6231;
  <D.6232>:
  monoeg_g_free (s);
  D.6233 = hash->in_use;
  D.6234 = D.6233 + -1;
  hash->in_use = D.6234;
  D.6217 = 1;
  return D.6217;
  <D.6228>:
  last = s;
  s = s->next;
  <D.5880>:
  if (s != 0B) goto <D.5879>; else goto <D.5881>;
  <D.5881>:
  D.6217 = 0;
  return D.6217;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6238;
  struct Slot * * D.6241;
  unsigned int i.9;
  unsigned int D.6243;
  struct Slot * * D.6244;
  void * D.6245;
  void * D.6246;
  int D.6247;
  struct Slot * D.6252;
  int D.6254;
  int D.6255;
  int D.6257;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6236>; else goto <D.6237>;
  <D.6236>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.6238 = 0;
  return D.6238;
  <D.6237>:
  if (func == 0B) goto <D.6239>; else goto <D.6240>;
  <D.6239>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.6238 = 0;
  return D.6238;
  <D.6240>:
  i = 0;
  goto <D.5896>;
  <D.5895>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6241 = hash->table;
    i.9 = (unsigned int) i;
    D.6243 = i.9 * 4;
    D.6244 = D.6241 + D.6243;
    s = *D.6244;
    goto <D.5893>;
    <D.5892>:
    D.6245 = s->key;
    D.6246 = s->value;
    D.6247 = func (D.6245, D.6246, user_data);
    if (D.6247 != 0) goto <D.6248>; else goto <D.6249>;
    <D.6248>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.6250>; else goto <D.6251>;
      <D.6250>:
      D.6241 = hash->table;
      i.9 = (unsigned int) i;
      D.6243 = i.9 * 4;
      D.6244 = D.6241 + D.6243;
      D.6252 = s->next;
      *D.6244 = D.6252;
      n = s->next;
      goto <D.6253>;
      <D.6251>:
      D.6252 = s->next;
      last->next = D.6252;
      n = last->next;
      <D.6253>:
      monoeg_g_free (s);
      D.6254 = hash->in_use;
      D.6255 = D.6254 + -1;
      hash->in_use = D.6255;
      count = count + 1;
      s = n;
    }
    goto <D.6256>;
    <D.6249>:
    last = s;
    s = s->next;
    <D.6256>:
    <D.5893>:
    if (s != 0B) goto <D.5892>; else goto <D.5894>;
    <D.5894>:
  }
  i = i + 1;
  <D.5896>:
  D.6257 = hash->table_size;
  if (D.6257 > i) goto <D.5895>; else goto <D.5897>;
  <D.5897>:
  if (count > 0) goto <D.6258>; else goto <D.6259>;
  <D.6258>:
  rehash (hash);
  <D.6259>:
  D.6238 = (guint) count;
  return D.6238;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.6263;
  unsigned int i.10;
  unsigned int D.6265;
  struct Slot * * D.6266;
  void (*<Tce8>) (void *) D.6267;
  void * D.6270;
  void (*<Tce8>) (void *) D.6271;
  void * D.6274;
  int D.6275;
  int i;

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

    D.6263 = hash->table;
    i.10 = (unsigned int) i;
    D.6265 = i.10 * 4;
    D.6266 = D.6263 + D.6265;
    s = *D.6266;
    goto <D.5905>;
    <D.5904>:
    next = s->next;
    D.6267 = hash->key_destroy_func;
    if (D.6267 != 0B) goto <D.6268>; else goto <D.6269>;
    <D.6268>:
    D.6267 = hash->key_destroy_func;
    D.6270 = s->key;
    D.6267 (D.6270);
    <D.6269>:
    D.6271 = hash->value_destroy_func;
    if (D.6271 != 0B) goto <D.6272>; else goto <D.6273>;
    <D.6272>:
    D.6271 = hash->value_destroy_func;
    D.6274 = s->value;
    D.6271 (D.6274);
    <D.6273>:
    monoeg_g_free (s);
    s = next;
    <D.5905>:
    if (s != 0B) goto <D.5904>; else goto <D.5906>;
    <D.5906>:
  }
  i = i + 1;
  <D.5908>:
  D.6275 = hash->table_size;
  if (D.6275 > i) goto <D.5907>; else goto <D.5909>;
  <D.5909>:
  D.6263 = hash->table;
  monoeg_g_free (D.6263);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.6277;
  unsigned int i.11;
  unsigned int D.6279;
  struct Slot * * D.6280;
  int D.6283;
  int D.6284;
  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.5922>;
  <D.5921>:
  chain_size = 0;
  D.6277 = table->table;
  i.11 = (unsigned int) i;
  D.6279 = i.11 * 4;
  D.6280 = D.6277 + D.6279;
  node = *D.6280;
  goto <D.5919>;
  <D.5918>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.5919>:
  if (node != 0B) goto <D.5918>; else goto <D.5920>;
  <D.5920>:
  if (chain_size > max_chain_size) goto <D.6281>; else goto <D.6282>;
  <D.6281>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.6282>:
  i = i + 1;
  <D.5922>:
  D.6283 = table->table_size;
  if (D.6283 > i) goto <D.5921>; else goto <D.5923>;
  <D.5923>:
  D.6284 = table->in_use;
  D.6283 = table->table_size;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.6284, D.6283, max_chain_size, max_chain_index);
}


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

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


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.6289;
  int D.6294;
  void * D.6296;
  unsigned int D.6297;

  D.6289 = __builtin_constant_p (__len);
  if (D.6289 != 0) goto <D.6290>; else goto <D.6291>;
  <D.6290>:
  if (__len == 0) goto <D.6292>; else goto <D.6293>;
  <D.6292>:
  D.6294 = __builtin_constant_p (__ch);
  if (D.6294 == 0) goto <D.6287>; else goto <D.6295>;
  <D.6295>:
  if (__ch != 0) goto <D.6287>; else goto <D.6288>;
  <D.6287>:
  __warn_memset_zero_len ();
  D.6296 = __dest;
  return D.6296;
  <D.6288>:
  <D.6293>:
  <D.6291>:
  D.6297 = __builtin_object_size (__dest, 0);
  D.6296 = __builtin___memset_chk (__dest, __ch, __len, D.6297);
  return D.6296;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.6299;
  _Bool D.6300;
  long int D.6301;
  long int D.6302;
  struct Slot * D.6307;
  int D.6310;
  int D.6311;
  gboolean D.6314;
  struct Slot * * D.6315;
  unsigned int D.6316;
  unsigned int D.6317;
  struct Slot * * D.6318;
  struct Slot * D.6319;
  void * D.6323;
  void * D.6326;
  struct Slot * D.6327;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.6299 = iter->slot_index;
  D.6300 = D.6299 == -2;
  D.6301 = (long int) D.6300;
  D.6302 = __builtin_expect (D.6301, 0);
  if (D.6302 != 0) goto <D.6303>; else goto <D.6304>;
  <D.6303>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.6304>:
  if (0 != 0) goto <D.6305>; else goto <D.6306>;
  <D.6305>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.6306>:
  D.6307 = iter->slot;
  if (D.6307 == 0B) goto <D.6308>; else goto <D.6309>;
  <D.6308>:
  <D.5937>:
  D.6299 = iter->slot_index;
  D.6310 = D.6299 + 1;
  iter->slot_index = D.6310;
  D.6299 = iter->slot_index;
  D.6311 = hash->table_size;
  if (D.6299 >= D.6311) goto <D.6312>; else goto <D.6313>;
  <D.6312>:
  iter->slot_index = -2;
  D.6314 = 0;
  return D.6314;
  <D.6313>:
  D.6315 = hash->table;
  D.6299 = iter->slot_index;
  D.6316 = (unsigned int) D.6299;
  D.6317 = D.6316 * 4;
  D.6318 = D.6315 + D.6317;
  D.6319 = *D.6318;
  if (D.6319 != 0B) goto <D.5936>; else goto <D.6320>;
  <D.6320>:
  goto <D.5937>;
  <D.5936>:
  D.6315 = hash->table;
  D.6299 = iter->slot_index;
  D.6316 = (unsigned int) D.6299;
  D.6317 = D.6316 * 4;
  D.6318 = D.6315 + D.6317;
  D.6319 = *D.6318;
  iter->slot = D.6319;
  <D.6309>:
  if (key != 0B) goto <D.6321>; else goto <D.6322>;
  <D.6321>:
  D.6307 = iter->slot;
  D.6323 = D.6307->key;
  *key = D.6323;
  <D.6322>:
  if (value != 0B) goto <D.6324>; else goto <D.6325>;
  <D.6324>:
  D.6307 = iter->slot;
  D.6326 = D.6307->value;
  *value = D.6326;
  <D.6325>:
  D.6307 = iter->slot;
  D.6327 = D.6307->next;
  iter->slot = D.6327;
  D.6314 = 1;
  return D.6314;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.6329;
  _Bool D.6330;

  D.6330 = v1 == v2;
  D.6329 = (gboolean) D.6330;
  return D.6329;
}


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

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


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.6334;
  int D.6335;
  int D.6336;
  _Bool D.6337;

  D.6335 = MEM[(gint *)v1];
  D.6336 = MEM[(gint *)v2];
  D.6337 = D.6335 == D.6336;
  D.6334 = (gboolean) D.6337;
  return D.6334;
}


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

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


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.6341;
  int D.5964;
  _Bool D.6342;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.5964 = __builtin_strcmp (v1, v2);
  }
  D.6342 = D.5964 == 0;
  D.6341 = (gboolean) D.6342;
  return D.6341;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.6344;
  char D.6345;
  unsigned int D.6346;
  unsigned int D.6347;
  char * p.12;
  char D.6349;
  guint D.6350;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.5971>;
  <D.5970>:
  D.6344 = hash << 5;
  D.6345 = *p;
  D.6346 = (unsigned int) D.6345;
  D.6347 = D.6346 + hash;
  hash = D.6344 - D.6347;
  <D.5971>:
  p.12 = p;
  p = p.12 + 1;
  D.6349 = *p.12;
  if (D.6349 != 0) goto <D.5970>; else goto <D.5972>;
  <D.5972>:
  D.6350 = hash;
  return D.6350;
}