monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.6073;
  guint D.6076;
  unsigned int i.0;
  int x.1;
  int D.6079;
  int i;

  i = 0;
  goto <D.5822>;
  <D.5821>:
  D.6073 = prime_tbl[i];
  if (D.6073 >= x) goto <D.6074>; else goto <D.6075>;
  <D.6074>:
  D.6076 = prime_tbl[i];
  return D.6076;
  <D.6075>:
  i = i + 1;
  <D.5822>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.5821>; else goto <D.5823>;
  <D.5823>:
  x.1 = (int) x;
  D.6079 = calc_prime (x.1);
  D.6076 = (guint) D.6079;
  return D.6076;
}


calc_prime (int x)
{
  int D.6081;
  int D.6082;
  int D.6085;
  int i;

  D.6081 = x & -2;
  i = D.6081 + -1;
  goto <D.5815>;
  <D.5814>:
  D.6082 = test_prime (i);
  if (D.6082 != 0) goto <D.6083>; else goto <D.6084>;
  <D.6083>:
  D.6085 = i;
  return D.6085;
  <D.6084>:
  i = i + 2;
  <D.5815>:
  if (i != 2147483647) goto <D.5814>; else goto <D.5816>;
  <D.5816>:
  D.6085 = x;
  return D.6085;
}


test_prime (int x)
{
  int D.6087;
  int D.6090;
  gboolean D.6093;
  double D.6094;
  double D.6095;
  int D.6096;
  _Bool D.6097;

  D.6087 = x & 1;
  if (D.6087 != 0) goto <D.6088>; else goto <D.6089>;
  <D.6088>:
  {
    int n;

    n = 3;
    goto <D.5808>;
    <D.5807>:
    D.6090 = x % n;
    if (D.6090 == 0) goto <D.6091>; else goto <D.6092>;
    <D.6091>:
    D.6093 = 0;
    return D.6093;
    <D.6092>:
    n = n + 2;
    <D.5808>:
    D.6094 = (double) x;
    D.6095 = sqrt (D.6094);
    D.6096 = (int) D.6095;
    if (D.6096 > n) goto <D.5807>; else goto <D.5809>;
    <D.5809>:
    D.6093 = 1;
    return D.6093;
  }
  <D.6089>:
  D.6097 = x == 2;
  D.6093 = (gboolean) D.6097;
  return D.6093;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.6103;
  int D.6104;
  int D.6105;
  unsigned int D.6106;
  unsigned int D.6107;
  void * D.6108;
  struct GHashTable * D.6109;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.6099>; else goto <D.6100>;
  <D.6099>:
  hash_func = monoeg_g_direct_hash;
  <D.6100>:
  if (key_equal_func == 0B) goto <D.6101>; else goto <D.6102>;
  <D.6101>:
  key_equal_func = monoeg_g_direct_equal;
  <D.6102>:
  hash = monoeg_malloc0 (36);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.6103 = monoeg_g_spaced_primes_closest (1);
  D.6104 = (int) D.6103;
  hash->table_size = D.6104;
  D.6105 = hash->table_size;
  D.6106 = (unsigned int) D.6105;
  D.6107 = D.6106 * 4;
  D.6108 = monoeg_malloc0 (D.6107);
  hash->table = D.6108;
  D.6105 = hash->table_size;
  hash->last_rehash = D.6105;
  D.6109 = hash;
  return D.6109;
}


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

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


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.6117;
  int D.6118;
  guint (*<Te2e>) (const void *) D.6121;
  unsigned int D.6122;
  int D.6123;
  unsigned int D.6124;
  struct Slot * * D.6125;
  unsigned int D.6126;
  struct Slot * * D.6127;
  void * D.6128;
  int D.6129;
  void (*<Td82>) (void *) D.6134;
  void (*<Td82>) (void *) D.6137;
  void * D.6140;
  struct Slot * D.6141;
  int D.6142;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.6115>; else goto <D.6116>;
  <D.6115>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.6116>:
  equal = hash->key_equal_func;
  D.6117 = hash->in_use;
  D.6118 = hash->threshold;
  if (D.6117 >= D.6118) goto <D.6119>; else goto <D.6120>;
  <D.6119>:
  rehash (hash);
  <D.6120>:
  D.6121 = hash->hash_func;
  D.6122 = D.6121 (key);
  D.6123 = hash->table_size;
  D.6124 = (unsigned int) D.6123;
  hashcode = D.6122 % D.6124;
  D.6125 = hash->table;
  D.6126 = hashcode * 4;
  D.6127 = D.6125 + D.6126;
  s = *D.6127;
  goto <D.5865>;
  <D.5864>:
  D.6128 = s->key;
  D.6129 = equal (D.6128, key);
  if (D.6129 != 0) goto <D.6130>; else goto <D.6131>;
  <D.6130>:
  if (replace != 0) goto <D.6132>; else goto <D.6133>;
  <D.6132>:
  D.6134 = hash->key_destroy_func;
  if (D.6134 != 0B) goto <D.6135>; else goto <D.6136>;
  <D.6135>:
  D.6134 = hash->key_destroy_func;
  D.6128 = s->key;
  D.6134 (D.6128);
  <D.6136>:
  s->key = key;
  <D.6133>:
  D.6137 = hash->value_destroy_func;
  if (D.6137 != 0B) goto <D.6138>; else goto <D.6139>;
  <D.6138>:
  D.6137 = hash->value_destroy_func;
  D.6140 = s->value;
  D.6137 (D.6140);
  <D.6139>:
  s->value = value;
  return;
  <D.6131>:
  s = s->next;
  <D.5865>:
  if (s != 0B) goto <D.5864>; else goto <D.5866>;
  <D.5866>:
  s = monoeg_malloc (12);
  s->key = key;
  s->value = value;
  D.6125 = hash->table;
  D.6126 = hashcode * 4;
  D.6127 = D.6125 + D.6126;
  D.6141 = *D.6127;
  s->next = D.6141;
  D.6125 = hash->table;
  D.6126 = hashcode * 4;
  D.6127 = D.6125 + D.6126;
  *D.6127 = s;
  D.6117 = hash->in_use;
  D.6142 = D.6117 + 1;
  hash->in_use = D.6142;
}


rehash (struct GHashTable * hash)
{
  int D.6144;
  int D.6145;
  int D.6146;
  double D.6147;
  double D.6148;
  int D.6149;
  int D.6150;
  double D.6151;
  _Bool D.6152;
  _Bool D.6153;
  int diff;

  D.6144 = hash->last_rehash;
  D.6145 = hash->in_use;
  D.6146 = D.6144 - D.6145;
  diff = ABS_EXPR <D.6146>;
  D.6147 = (double) diff;
  D.6148 = D.6147 * 7.5e-1;
  D.6149 = hash->table_size;
  D.6150 = D.6149 * 2;
  D.6151 = (double) D.6150;
  D.6152 = D.6148 > D.6151;
  D.6153 = ~D.6152;
  if (D.6153 != 0) goto <D.6154>; else goto <D.6155>;
  <D.6154>:
  return;
  <D.6155>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.6157;
  int D.6158;
  unsigned int D.6159;
  unsigned int D.6160;
  int D.6161;
  unsigned int D.6162;
  unsigned int D.6163;
  void * D.6164;
  unsigned int i.2;
  unsigned int D.6166;
  struct Slot * * D.6167;
  guint (*<Te2e>) (const void *) D.6168;
  void * D.6169;
  unsigned int D.6170;
  unsigned int D.6171;
  struct Slot * * D.6172;
  unsigned int D.6173;
  struct Slot * * D.6174;
  struct Slot * D.6175;
  int current_size;
  int i;
  struct Slot * * table;

  D.6157 = hash->table_size;
  hash->last_rehash = D.6157;
  current_size = hash->table_size;
  D.6158 = hash->in_use;
  D.6159 = (unsigned int) D.6158;
  D.6160 = monoeg_g_spaced_primes_closest (D.6159);
  D.6161 = (int) D.6160;
  hash->table_size = D.6161;
  table = hash->table;
  D.6157 = hash->table_size;
  D.6162 = (unsigned int) D.6157;
  D.6163 = D.6162 * 4;
  D.6164 = monoeg_malloc0 (D.6163);
  hash->table = D.6164;
  i = 0;
  goto <D.5849>;
  <D.5848>:
  {
    struct Slot * s;
    struct Slot * next;

    i.2 = (unsigned int) i;
    D.6166 = i.2 * 4;
    D.6167 = table + D.6166;
    s = *D.6167;
    goto <D.5846>;
    <D.5845>:
    {
      guint hashcode;

      D.6168 = hash->hash_func;
      D.6169 = s->key;
      D.6170 = D.6168 (D.6169);
      D.6157 = hash->table_size;
      D.6171 = (unsigned int) D.6157;
      hashcode = D.6170 % D.6171;
      next = s->next;
      D.6172 = hash->table;
      D.6173 = hashcode * 4;
      D.6174 = D.6172 + D.6173;
      D.6175 = *D.6174;
      s->next = D.6175;
      D.6172 = hash->table;
      D.6173 = hashcode * 4;
      D.6174 = D.6172 + D.6173;
      *D.6174 = s;
    }
    s = next;
    <D.5846>:
    if (s != 0B) goto <D.5845>; else goto <D.5847>;
    <D.5847>:
  }
  i = i + 1;
  <D.5849>:
  if (i < current_size) goto <D.5848>; else goto <D.5850>;
  <D.5850>:
  monoeg_g_free (table);
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.5874>;
      <D.5873>:
      key.3 = key;
      rv = monoeg_g_list_prepend (rv, key.3);
      <D.5874>:
      D.6177 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.6177 != 0) goto <D.5873>; else goto <D.5875>;
      <D.5875>:
      D.6178 = monoeg_g_list_reverse (rv);
      return D.6178;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.5883>;
      <D.5882>:
      value.4 = value;
      rv = monoeg_g_list_prepend (rv, value.4);
      <D.5883>:
      D.6182 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.6182 != 0) goto <D.5882>; else goto <D.5884>;
      <D.5884>:
      D.6183 = monoeg_g_list_reverse (rv);
      return D.6183;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.6188;
  int D.6189;

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


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

  try
    {
      D.6191 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.6191 != 0) goto <D.6192>; else goto <D.6193>;
      <D.6192>:
      D.6194 = value;
      return D.6194;
      <D.6193>:
      D.6194 = 0B;
      return D.6194;
    }
  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.6199;
  guint (*<Te2e>) (const void *) D.6200;
  unsigned int D.6201;
  int D.6202;
  unsigned int D.6203;
  struct Slot * * D.6204;
  unsigned int D.6205;
  struct Slot * * D.6206;
  void * D.6207;
  int D.6208;
  void * D.6215;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.6197>; else goto <D.6198>;
  <D.6197>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.6199 = 0;
  return D.6199;
  <D.6198>:
  equal = hash->key_equal_func;
  D.6200 = hash->hash_func;
  D.6201 = D.6200 (key);
  D.6202 = hash->table_size;
  D.6203 = (unsigned int) D.6202;
  hashcode = D.6201 % D.6203;
  D.6204 = hash->table;
  D.6205 = hashcode * 4;
  D.6206 = D.6204 + D.6205;
  s = *D.6206;
  goto <D.5904>;
  <D.5903>:
  D.6207 = s->key;
  D.6208 = equal (D.6207, key);
  if (D.6208 != 0) goto <D.6209>; else goto <D.6210>;
  <D.6209>:
  if (orig_key != 0B) goto <D.6211>; else goto <D.6212>;
  <D.6211>:
  D.6207 = s->key;
  *orig_key = D.6207;
  <D.6212>:
  if (value != 0B) goto <D.6213>; else goto <D.6214>;
  <D.6213>:
  D.6215 = s->value;
  *value = D.6215;
  <D.6214>:
  D.6199 = 1;
  return D.6199;
  <D.6210>:
  s = s->next;
  <D.5904>:
  if (s != 0B) goto <D.5903>; else goto <D.5905>;
  <D.5905>:
  D.6199 = 0;
  return D.6199;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.6221;
  unsigned int i.5;
  unsigned int D.6223;
  struct Slot * * D.6224;
  void * D.6225;
  void * D.6226;
  int D.6227;
  int i;

  if (hash == 0B) goto <D.6217>; else goto <D.6218>;
  <D.6217>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.6218>:
  if (func == 0B) goto <D.6219>; else goto <D.6220>;
  <D.6219>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.6220>:
  i = 0;
  goto <D.5917>;
  <D.5916>:
  {
    struct Slot * s;

    D.6221 = hash->table;
    i.5 = (unsigned int) i;
    D.6223 = i.5 * 4;
    D.6224 = D.6221 + D.6223;
    s = *D.6224;
    goto <D.5914>;
    <D.5913>:
    D.6225 = s->value;
    D.6226 = s->key;
    func (D.6226, D.6225, user_data);
    s = s->next;
    <D.5914>:
    if (s != 0B) goto <D.5913>; else goto <D.5915>;
    <D.5915>:
  }
  i = i + 1;
  <D.5917>:
  D.6227 = hash->table_size;
  if (D.6227 > i) goto <D.5916>; else goto <D.5918>;
  <D.5918>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.6231;
  struct Slot * * D.6234;
  unsigned int i.6;
  unsigned int D.6236;
  struct Slot * * D.6237;
  void * D.6238;
  void * D.6239;
  int D.6240;
  int D.6243;
  int i;

  if (hash == 0B) goto <D.6229>; else goto <D.6230>;
  <D.6229>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.6231 = 0B;
  return D.6231;
  <D.6230>:
  if (predicate == 0B) goto <D.6232>; else goto <D.6233>;
  <D.6232>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.6231 = 0B;
  return D.6231;
  <D.6233>:
  i = 0;
  goto <D.5930>;
  <D.5929>:
  {
    struct Slot * s;

    D.6234 = hash->table;
    i.6 = (unsigned int) i;
    D.6236 = i.6 * 4;
    D.6237 = D.6234 + D.6236;
    s = *D.6237;
    goto <D.5927>;
    <D.5926>:
    D.6238 = s->value;
    D.6239 = s->key;
    D.6240 = predicate (D.6239, D.6238, user_data);
    if (D.6240 != 0) goto <D.6241>; else goto <D.6242>;
    <D.6241>:
    D.6231 = s->value;
    return D.6231;
    <D.6242>:
    s = s->next;
    <D.5927>:
    if (s != 0B) goto <D.5926>; else goto <D.5928>;
    <D.5928>:
  }
  i = i + 1;
  <D.5930>:
  D.6243 = hash->table_size;
  if (D.6243 > i) goto <D.5929>; else goto <D.5931>;
  <D.5931>:
  D.6231 = 0B;
  return D.6231;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.6247;
  unsigned int i.7;
  unsigned int D.6249;
  struct Slot * * D.6250;
  void * D.6251;
  struct Slot * D.6252;
  int D.6253;
  int i;

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

    goto <D.5938>;
    <D.5937>:
    D.6247 = hash->table;
    i.7 = (unsigned int) i;
    D.6249 = i.7 * 4;
    D.6250 = D.6247 + D.6249;
    s = *D.6250;
    D.6251 = s->key;
    monoeg_g_hash_table_remove (hash, D.6251);
    <D.5938>:
    D.6247 = hash->table;
    i.7 = (unsigned int) i;
    D.6249 = i.7 * 4;
    D.6250 = D.6247 + D.6249;
    D.6252 = *D.6250;
    if (D.6252 != 0B) goto <D.5937>; else goto <D.5939>;
    <D.5939>:
  }
  i = i + 1;
  <D.5941>:
  D.6253 = hash->table_size;
  if (D.6253 > i) goto <D.5940>; else goto <D.5942>;
  <D.5942>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.6257;
  guint (*<Te2e>) (const void *) D.6258;
  unsigned int D.6259;
  int D.6260;
  unsigned int D.6261;
  struct Slot * * D.6262;
  unsigned int D.6263;
  struct Slot * * D.6264;
  void * D.6265;
  int D.6266;
  void (*<Td82>) (void *) D.6269;
  void (*<Td82>) (void *) D.6272;
  void * D.6275;
  struct Slot * D.6278;
  int D.6280;
  int D.6281;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6255>; else goto <D.6256>;
  <D.6255>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.6257 = 0;
  return D.6257;
  <D.6256>:
  equal = hash->key_equal_func;
  D.6258 = hash->hash_func;
  D.6259 = D.6258 (key);
  D.6260 = hash->table_size;
  D.6261 = (unsigned int) D.6260;
  hashcode = D.6259 % D.6261;
  last = 0B;
  D.6262 = hash->table;
  D.6263 = hashcode * 4;
  D.6264 = D.6262 + D.6263;
  s = *D.6264;
  goto <D.5952>;
  <D.5951>:
  D.6265 = s->key;
  D.6266 = equal (D.6265, key);
  if (D.6266 != 0) goto <D.6267>; else goto <D.6268>;
  <D.6267>:
  D.6269 = hash->key_destroy_func;
  if (D.6269 != 0B) goto <D.6270>; else goto <D.6271>;
  <D.6270>:
  D.6269 = hash->key_destroy_func;
  D.6265 = s->key;
  D.6269 (D.6265);
  <D.6271>:
  D.6272 = hash->value_destroy_func;
  if (D.6272 != 0B) goto <D.6273>; else goto <D.6274>;
  <D.6273>:
  D.6272 = hash->value_destroy_func;
  D.6275 = s->value;
  D.6272 (D.6275);
  <D.6274>:
  if (last == 0B) goto <D.6276>; else goto <D.6277>;
  <D.6276>:
  D.6262 = hash->table;
  D.6263 = hashcode * 4;
  D.6264 = D.6262 + D.6263;
  D.6278 = s->next;
  *D.6264 = D.6278;
  goto <D.6279>;
  <D.6277>:
  D.6278 = s->next;
  last->next = D.6278;
  <D.6279>:
  monoeg_g_free (s);
  D.6280 = hash->in_use;
  D.6281 = D.6280 + -1;
  hash->in_use = D.6281;
  D.6257 = 1;
  return D.6257;
  <D.6268>:
  last = s;
  s = s->next;
  <D.5952>:
  if (s != 0B) goto <D.5951>; else goto <D.5953>;
  <D.5953>:
  D.6257 = 0;
  return D.6257;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6285;
  struct Slot * * D.6288;
  unsigned int i.8;
  unsigned int D.6290;
  struct Slot * * D.6291;
  void * D.6292;
  void * D.6293;
  int D.6294;
  void (*<Td82>) (void *) D.6297;
  void (*<Td82>) (void *) D.6300;
  struct Slot * D.6305;
  int D.6307;
  int D.6308;
  int D.6310;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6283>; else goto <D.6284>;
  <D.6283>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.6285 = 0;
  return D.6285;
  <D.6284>:
  if (func == 0B) goto <D.6286>; else goto <D.6287>;
  <D.6286>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.6285 = 0;
  return D.6285;
  <D.6287>:
  i = 0;
  goto <D.5968>;
  <D.5967>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6288 = hash->table;
    i.8 = (unsigned int) i;
    D.6290 = i.8 * 4;
    D.6291 = D.6288 + D.6290;
    s = *D.6291;
    goto <D.5965>;
    <D.5964>:
    D.6292 = s->value;
    D.6293 = s->key;
    D.6294 = func (D.6293, D.6292, user_data);
    if (D.6294 != 0) goto <D.6295>; else goto <D.6296>;
    <D.6295>:
    {
      struct Slot * n;

      D.6297 = hash->key_destroy_func;
      if (D.6297 != 0B) goto <D.6298>; else goto <D.6299>;
      <D.6298>:
      D.6297 = hash->key_destroy_func;
      D.6293 = s->key;
      D.6297 (D.6293);
      <D.6299>:
      D.6300 = hash->value_destroy_func;
      if (D.6300 != 0B) goto <D.6301>; else goto <D.6302>;
      <D.6301>:
      D.6300 = hash->value_destroy_func;
      D.6292 = s->value;
      D.6300 (D.6292);
      <D.6302>:
      if (last == 0B) goto <D.6303>; else goto <D.6304>;
      <D.6303>:
      D.6288 = hash->table;
      i.8 = (unsigned int) i;
      D.6290 = i.8 * 4;
      D.6291 = D.6288 + D.6290;
      D.6305 = s->next;
      *D.6291 = D.6305;
      n = s->next;
      goto <D.6306>;
      <D.6304>:
      D.6305 = s->next;
      last->next = D.6305;
      n = last->next;
      <D.6306>:
      monoeg_g_free (s);
      D.6307 = hash->in_use;
      D.6308 = D.6307 + -1;
      hash->in_use = D.6308;
      count = count + 1;
      s = n;
    }
    goto <D.6309>;
    <D.6296>:
    last = s;
    s = s->next;
    <D.6309>:
    <D.5965>:
    if (s != 0B) goto <D.5964>; else goto <D.5966>;
    <D.5966>:
  }
  i = i + 1;
  <D.5968>:
  D.6310 = hash->table_size;
  if (D.6310 > i) goto <D.5967>; else goto <D.5969>;
  <D.5969>:
  if (count > 0) goto <D.6311>; else goto <D.6312>;
  <D.6311>:
  rehash (hash);
  <D.6312>:
  D.6285 = (guint) count;
  return D.6285;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.6316;
  guint (*<Te2e>) (const void *) D.6317;
  unsigned int D.6318;
  int D.6319;
  unsigned int D.6320;
  struct Slot * * D.6321;
  unsigned int D.6322;
  struct Slot * * D.6323;
  void * D.6324;
  int D.6325;
  struct Slot * D.6330;
  int D.6332;
  int D.6333;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6314>; else goto <D.6315>;
  <D.6314>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.6316 = 0;
  return D.6316;
  <D.6315>:
  equal = hash->key_equal_func;
  D.6317 = hash->hash_func;
  D.6318 = D.6317 (key);
  D.6319 = hash->table_size;
  D.6320 = (unsigned int) D.6319;
  hashcode = D.6318 % D.6320;
  last = 0B;
  D.6321 = hash->table;
  D.6322 = hashcode * 4;
  D.6323 = D.6321 + D.6322;
  s = *D.6323;
  goto <D.5979>;
  <D.5978>:
  D.6324 = s->key;
  D.6325 = equal (D.6324, key);
  if (D.6325 != 0) goto <D.6326>; else goto <D.6327>;
  <D.6326>:
  if (last == 0B) goto <D.6328>; else goto <D.6329>;
  <D.6328>:
  D.6321 = hash->table;
  D.6322 = hashcode * 4;
  D.6323 = D.6321 + D.6322;
  D.6330 = s->next;
  *D.6323 = D.6330;
  goto <D.6331>;
  <D.6329>:
  D.6330 = s->next;
  last->next = D.6330;
  <D.6331>:
  monoeg_g_free (s);
  D.6332 = hash->in_use;
  D.6333 = D.6332 + -1;
  hash->in_use = D.6333;
  D.6316 = 1;
  return D.6316;
  <D.6327>:
  last = s;
  s = s->next;
  <D.5979>:
  if (s != 0B) goto <D.5978>; else goto <D.5980>;
  <D.5980>:
  D.6316 = 0;
  return D.6316;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6337;
  struct Slot * * D.6340;
  unsigned int i.9;
  unsigned int D.6342;
  struct Slot * * D.6343;
  void * D.6344;
  void * D.6345;
  int D.6346;
  struct Slot * D.6351;
  int D.6353;
  int D.6354;
  int D.6356;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6335>; else goto <D.6336>;
  <D.6335>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.6337 = 0;
  return D.6337;
  <D.6336>:
  if (func == 0B) goto <D.6338>; else goto <D.6339>;
  <D.6338>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.6337 = 0;
  return D.6337;
  <D.6339>:
  i = 0;
  goto <D.5995>;
  <D.5994>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6340 = hash->table;
    i.9 = (unsigned int) i;
    D.6342 = i.9 * 4;
    D.6343 = D.6340 + D.6342;
    s = *D.6343;
    goto <D.5992>;
    <D.5991>:
    D.6344 = s->value;
    D.6345 = s->key;
    D.6346 = func (D.6345, D.6344, user_data);
    if (D.6346 != 0) goto <D.6347>; else goto <D.6348>;
    <D.6347>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.6349>; else goto <D.6350>;
      <D.6349>:
      D.6340 = hash->table;
      i.9 = (unsigned int) i;
      D.6342 = i.9 * 4;
      D.6343 = D.6340 + D.6342;
      D.6351 = s->next;
      *D.6343 = D.6351;
      n = s->next;
      goto <D.6352>;
      <D.6350>:
      D.6351 = s->next;
      last->next = D.6351;
      n = last->next;
      <D.6352>:
      monoeg_g_free (s);
      D.6353 = hash->in_use;
      D.6354 = D.6353 + -1;
      hash->in_use = D.6354;
      count = count + 1;
      s = n;
    }
    goto <D.6355>;
    <D.6348>:
    last = s;
    s = s->next;
    <D.6355>:
    <D.5992>:
    if (s != 0B) goto <D.5991>; else goto <D.5993>;
    <D.5993>:
  }
  i = i + 1;
  <D.5995>:
  D.6356 = hash->table_size;
  if (D.6356 > i) goto <D.5994>; else goto <D.5996>;
  <D.5996>:
  if (count > 0) goto <D.6357>; else goto <D.6358>;
  <D.6357>:
  rehash (hash);
  <D.6358>:
  D.6337 = (guint) count;
  return D.6337;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.6362;
  unsigned int i.10;
  unsigned int D.6364;
  struct Slot * * D.6365;
  void (*<Td82>) (void *) D.6366;
  void * D.6369;
  void (*<Td82>) (void *) D.6370;
  void * D.6373;
  int D.6374;
  int i;

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

    D.6362 = hash->table;
    i.10 = (unsigned int) i;
    D.6364 = i.10 * 4;
    D.6365 = D.6362 + D.6364;
    s = *D.6365;
    goto <D.6004>;
    <D.6003>:
    next = s->next;
    D.6366 = hash->key_destroy_func;
    if (D.6366 != 0B) goto <D.6367>; else goto <D.6368>;
    <D.6367>:
    D.6366 = hash->key_destroy_func;
    D.6369 = s->key;
    D.6366 (D.6369);
    <D.6368>:
    D.6370 = hash->value_destroy_func;
    if (D.6370 != 0B) goto <D.6371>; else goto <D.6372>;
    <D.6371>:
    D.6370 = hash->value_destroy_func;
    D.6373 = s->value;
    D.6370 (D.6373);
    <D.6372>:
    monoeg_g_free (s);
    s = next;
    <D.6004>:
    if (s != 0B) goto <D.6003>; else goto <D.6005>;
    <D.6005>:
  }
  i = i + 1;
  <D.6007>:
  D.6374 = hash->table_size;
  if (D.6374 > i) goto <D.6006>; else goto <D.6008>;
  <D.6008>:
  D.6362 = hash->table;
  monoeg_g_free (D.6362);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.6376;
  unsigned int i.11;
  unsigned int D.6378;
  struct Slot * * D.6379;
  int D.6382;
  int D.6383;
  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.6021>;
  <D.6020>:
  chain_size = 0;
  D.6376 = table->table;
  i.11 = (unsigned int) i;
  D.6378 = i.11 * 4;
  D.6379 = D.6376 + D.6378;
  node = *D.6379;
  goto <D.6018>;
  <D.6017>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.6018>:
  if (node != 0B) goto <D.6017>; else goto <D.6019>;
  <D.6019>:
  if (chain_size > max_chain_size) goto <D.6380>; else goto <D.6381>;
  <D.6380>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.6381>:
  i = i + 1;
  <D.6021>:
  D.6382 = table->table_size;
  if (D.6382 > i) goto <D.6020>; else goto <D.6022>;
  <D.6022>:
  D.6382 = table->table_size;
  D.6383 = table->in_use;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.6383, D.6382, max_chain_size, max_chain_index);
}


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

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


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.6388;
  int D.6393;
  void * D.6395;
  unsigned int D.6396;

  D.6388 = __builtin_constant_p (__len);
  if (D.6388 != 0) goto <D.6389>; else goto <D.6390>;
  <D.6389>:
  if (__len == 0) goto <D.6391>; else goto <D.6392>;
  <D.6391>:
  D.6393 = __builtin_constant_p (__ch);
  if (D.6393 == 0) goto <D.6386>; else goto <D.6394>;
  <D.6394>:
  if (__ch != 0) goto <D.6386>; else goto <D.6387>;
  <D.6386>:
  __warn_memset_zero_len ();
  D.6395 = __dest;
  return D.6395;
  <D.6387>:
  <D.6392>:
  <D.6390>:
  D.6396 = __builtin_object_size (__dest, 0);
  D.6395 = __builtin___memset_chk (__dest, __ch, __len, D.6396);
  return D.6395;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.6398;
  _Bool D.6399;
  long int D.6400;
  long int D.6401;
  struct Slot * D.6406;
  int D.6409;
  int D.6410;
  gboolean D.6413;
  struct Slot * * D.6414;
  unsigned int D.6415;
  unsigned int D.6416;
  struct Slot * * D.6417;
  struct Slot * D.6418;
  void * D.6422;
  void * D.6425;
  struct Slot * D.6426;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.6398 = iter->slot_index;
  D.6399 = D.6398 == -2;
  D.6400 = (long int) D.6399;
  D.6401 = __builtin_expect (D.6400, 0);
  if (D.6401 != 0) goto <D.6402>; else goto <D.6403>;
  <D.6402>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.6403>:
  if (0 != 0) goto <D.6404>; else goto <D.6405>;
  <D.6404>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.6405>:
  D.6406 = iter->slot;
  if (D.6406 == 0B) goto <D.6407>; else goto <D.6408>;
  <D.6407>:
  <D.6036>:
  D.6398 = iter->slot_index;
  D.6409 = D.6398 + 1;
  iter->slot_index = D.6409;
  D.6398 = iter->slot_index;
  D.6410 = hash->table_size;
  if (D.6398 >= D.6410) goto <D.6411>; else goto <D.6412>;
  <D.6411>:
  iter->slot_index = -2;
  D.6413 = 0;
  return D.6413;
  <D.6412>:
  D.6414 = hash->table;
  D.6398 = iter->slot_index;
  D.6415 = (unsigned int) D.6398;
  D.6416 = D.6415 * 4;
  D.6417 = D.6414 + D.6416;
  D.6418 = *D.6417;
  if (D.6418 != 0B) goto <D.6035>; else goto <D.6419>;
  <D.6419>:
  goto <D.6036>;
  <D.6035>:
  D.6414 = hash->table;
  D.6398 = iter->slot_index;
  D.6415 = (unsigned int) D.6398;
  D.6416 = D.6415 * 4;
  D.6417 = D.6414 + D.6416;
  D.6418 = *D.6417;
  iter->slot = D.6418;
  <D.6408>:
  if (key != 0B) goto <D.6420>; else goto <D.6421>;
  <D.6420>:
  D.6406 = iter->slot;
  D.6422 = D.6406->key;
  *key = D.6422;
  <D.6421>:
  if (value != 0B) goto <D.6423>; else goto <D.6424>;
  <D.6423>:
  D.6406 = iter->slot;
  D.6425 = D.6406->value;
  *value = D.6425;
  <D.6424>:
  D.6406 = iter->slot;
  D.6426 = D.6406->next;
  iter->slot = D.6426;
  D.6413 = 1;
  return D.6413;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.6428;
  _Bool D.6429;

  D.6429 = v1 == v2;
  D.6428 = (gboolean) D.6429;
  return D.6428;
}


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

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


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.6433;
  int D.6434;
  int D.6435;
  _Bool D.6436;

  D.6434 = MEM[(gint *)v1];
  D.6435 = MEM[(gint *)v2];
  D.6436 = D.6434 == D.6435;
  D.6433 = (gboolean) D.6436;
  return D.6433;
}


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

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


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.6440;
  int D.6063;
  _Bool D.6441;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.6063 = __builtin_strcmp (v1, v2);
  }
  D.6441 = D.6063 == 0;
  D.6440 = (gboolean) D.6441;
  return D.6440;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.6443;
  char D.6444;
  unsigned int D.6445;
  unsigned int D.6446;
  char * p.12;
  char D.6448;
  guint D.6449;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.6070>;
  <D.6069>:
  D.6443 = hash << 5;
  D.6444 = *p;
  D.6445 = (unsigned int) D.6444;
  D.6446 = D.6445 + hash;
  hash = D.6443 - D.6446;
  <D.6070>:
  p.12 = p;
  p = p.12 + 1;
  D.6448 = *p.12;
  if (D.6448 != 0) goto <D.6069>; else goto <D.6071>;
  <D.6071>:
  D.6449 = hash;
  return D.6449;
}