monoeg_g_spaced_primes_closest (guint x)
{
  unsigned int D.6680;
  guint D.6683;
  unsigned int i.0;
  int x.1;
  int D.6686;
  int i;

  i = 0;
  goto <D.6429>;
  <D.6428>:
  D.6680 = prime_tbl[i];
  if (D.6680 >= x) goto <D.6681>; else goto <D.6682>;
  <D.6681>:
  D.6683 = prime_tbl[i];
  return D.6683;
  <D.6682>:
  i = i + 1;
  <D.6429>:
  i.0 = (unsigned int) i;
  if (i.0 <= 33) goto <D.6428>; else goto <D.6430>;
  <D.6430>:
  x.1 = (int) x;
  D.6686 = calc_prime (x.1);
  D.6683 = (guint) D.6686;
  return D.6683;
}


calc_prime (int x)
{
  int D.6688;
  int D.6689;
  int D.6692;
  int i;

  D.6688 = x & -2;
  i = D.6688 + -1;
  goto <D.6422>;
  <D.6421>:
  D.6689 = test_prime (i);
  if (D.6689 != 0) goto <D.6690>; else goto <D.6691>;
  <D.6690>:
  D.6692 = i;
  return D.6692;
  <D.6691>:
  i = i + 2;
  <D.6422>:
  if (i != 2147483647) goto <D.6421>; else goto <D.6423>;
  <D.6423>:
  D.6692 = x;
  return D.6692;
}


test_prime (int x)
{
  int D.6694;
  int D.6697;
  gboolean D.6700;
  double D.6701;
  double D.6702;
  int D.6703;
  _Bool D.6704;

  D.6694 = x & 1;
  if (D.6694 != 0) goto <D.6695>; else goto <D.6696>;
  <D.6695>:
  {
    int n;

    n = 3;
    goto <D.6415>;
    <D.6414>:
    D.6697 = x % n;
    if (D.6697 == 0) goto <D.6698>; else goto <D.6699>;
    <D.6698>:
    D.6700 = 0;
    return D.6700;
    <D.6699>:
    n = n + 2;
    <D.6415>:
    D.6701 = (double) x;
    D.6702 = sqrt (D.6701);
    D.6703 = (int) D.6702;
    if (D.6703 > n) goto <D.6414>; else goto <D.6416>;
    <D.6416>:
    D.6700 = 1;
    return D.6700;
  }
  <D.6696>:
  D.6704 = x == 2;
  D.6700 = (gboolean) D.6704;
  return D.6700;
}


monoeg_g_hash_table_new (guint (*GHashFunc) (const void *) hash_func, gboolean (*GEqualFunc) (const void *, const void *) key_equal_func)
{
  unsigned int D.6710;
  int D.6711;
  int D.6712;
  long unsigned int D.6713;
  long unsigned int D.6714;
  void * D.6715;
  struct GHashTable * D.6716;
  struct GHashTable * hash;

  if (hash_func == 0B) goto <D.6706>; else goto <D.6707>;
  <D.6706>:
  hash_func = monoeg_g_direct_hash;
  <D.6707>:
  if (key_equal_func == 0B) goto <D.6708>; else goto <D.6709>;
  <D.6708>:
  key_equal_func = monoeg_g_direct_equal;
  <D.6709>:
  hash = monoeg_malloc0 (56);
  hash->hash_func = hash_func;
  hash->key_equal_func = key_equal_func;
  D.6710 = monoeg_g_spaced_primes_closest (1);
  D.6711 = (int) D.6710;
  hash->table_size = D.6711;
  D.6712 = hash->table_size;
  D.6713 = (long unsigned int) D.6712;
  D.6714 = D.6713 * 8;
  D.6715 = monoeg_malloc0 (D.6714);
  hash->table = D.6715;
  D.6712 = hash->table_size;
  hash->last_rehash = D.6712;
  D.6716 = hash;
  return D.6716;
}


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

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


monoeg_g_hash_table_insert_replace (struct GHashTable * hash, void * key, void * value, gboolean replace)
{
  int D.6724;
  int D.6725;
  guint (*<Tf2e>) (const void *) D.6728;
  unsigned int D.6729;
  int D.6730;
  unsigned int D.6731;
  struct Slot * * D.6732;
  long unsigned int D.6733;
  long unsigned int D.6734;
  struct Slot * * D.6735;
  void * D.6736;
  int D.6737;
  void (*<Te82>) (void *) D.6742;
  void (*<Te82>) (void *) D.6745;
  void * D.6748;
  struct Slot * D.6749;
  int D.6750;
  guint hashcode;
  struct Slot * s;
  gboolean (*GEqualFunc) (const void *, const void *) equal;

  if (hash == 0B) goto <D.6722>; else goto <D.6723>;
  <D.6722>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 236, "hash != NULL");
  return;
  <D.6723>:
  equal = hash->key_equal_func;
  D.6724 = hash->in_use;
  D.6725 = hash->threshold;
  if (D.6724 >= D.6725) goto <D.6726>; else goto <D.6727>;
  <D.6726>:
  rehash (hash);
  <D.6727>:
  D.6728 = hash->hash_func;
  D.6729 = D.6728 (key);
  D.6730 = hash->table_size;
  D.6731 = (unsigned int) D.6730;
  hashcode = D.6729 % D.6731;
  D.6732 = hash->table;
  D.6733 = (long unsigned int) hashcode;
  D.6734 = D.6733 * 8;
  D.6735 = D.6732 + D.6734;
  s = *D.6735;
  goto <D.6472>;
  <D.6471>:
  D.6736 = s->key;
  D.6737 = equal (D.6736, key);
  if (D.6737 != 0) goto <D.6738>; else goto <D.6739>;
  <D.6738>:
  if (replace != 0) goto <D.6740>; else goto <D.6741>;
  <D.6740>:
  D.6742 = hash->key_destroy_func;
  if (D.6742 != 0B) goto <D.6743>; else goto <D.6744>;
  <D.6743>:
  D.6742 = hash->key_destroy_func;
  D.6736 = s->key;
  D.6742 (D.6736);
  <D.6744>:
  s->key = key;
  <D.6741>:
  D.6745 = hash->value_destroy_func;
  if (D.6745 != 0B) goto <D.6746>; else goto <D.6747>;
  <D.6746>:
  D.6745 = hash->value_destroy_func;
  D.6748 = s->value;
  D.6745 (D.6748);
  <D.6747>:
  s->value = value;
  return;
  <D.6739>:
  s = s->next;
  <D.6472>:
  if (s != 0B) goto <D.6471>; else goto <D.6473>;
  <D.6473>:
  s = monoeg_malloc (24);
  s->key = key;
  s->value = value;
  D.6732 = hash->table;
  D.6733 = (long unsigned int) hashcode;
  D.6734 = D.6733 * 8;
  D.6735 = D.6732 + D.6734;
  D.6749 = *D.6735;
  s->next = D.6749;
  D.6732 = hash->table;
  D.6733 = (long unsigned int) hashcode;
  D.6734 = D.6733 * 8;
  D.6735 = D.6732 + D.6734;
  *D.6735 = s;
  D.6724 = hash->in_use;
  D.6750 = D.6724 + 1;
  hash->in_use = D.6750;
}


rehash (struct GHashTable * hash)
{
  int D.6752;
  int D.6753;
  int D.6754;
  double D.6755;
  double D.6756;
  int D.6757;
  int D.6758;
  double D.6759;
  _Bool D.6760;
  _Bool D.6761;
  int diff;

  D.6752 = hash->last_rehash;
  D.6753 = hash->in_use;
  D.6754 = D.6752 - D.6753;
  diff = ABS_EXPR <D.6754>;
  D.6755 = (double) diff;
  D.6756 = D.6755 * 7.5e-1;
  D.6757 = hash->table_size;
  D.6758 = D.6757 * 2;
  D.6759 = (double) D.6758;
  D.6760 = D.6756 > D.6759;
  D.6761 = ~D.6760;
  if (D.6761 != 0) goto <D.6762>; else goto <D.6763>;
  <D.6762>:
  return;
  <D.6763>:
  do_rehash (hash);
}


do_rehash (struct GHashTable * hash)
{
  int D.6765;
  int D.6766;
  unsigned int D.6767;
  unsigned int D.6768;
  int D.6769;
  long unsigned int D.6770;
  long unsigned int D.6771;
  void * D.6772;
  long unsigned int D.6773;
  long unsigned int D.6774;
  struct Slot * * D.6775;
  guint (*<Tf2e>) (const void *) D.6776;
  void * D.6777;
  unsigned int D.6778;
  unsigned int D.6779;
  struct Slot * * D.6780;
  long unsigned int D.6781;
  long unsigned int D.6782;
  struct Slot * * D.6783;
  struct Slot * D.6784;
  int current_size;
  int i;
  struct Slot * * table;

  D.6765 = hash->table_size;
  hash->last_rehash = D.6765;
  current_size = hash->table_size;
  D.6766 = hash->in_use;
  D.6767 = (unsigned int) D.6766;
  D.6768 = monoeg_g_spaced_primes_closest (D.6767);
  D.6769 = (int) D.6768;
  hash->table_size = D.6769;
  table = hash->table;
  D.6765 = hash->table_size;
  D.6770 = (long unsigned int) D.6765;
  D.6771 = D.6770 * 8;
  D.6772 = monoeg_malloc0 (D.6771);
  hash->table = D.6772;
  i = 0;
  goto <D.6456>;
  <D.6455>:
  {
    struct Slot * s;
    struct Slot * next;

    D.6773 = (long unsigned int) i;
    D.6774 = D.6773 * 8;
    D.6775 = table + D.6774;
    s = *D.6775;
    goto <D.6453>;
    <D.6452>:
    {
      guint hashcode;

      D.6776 = hash->hash_func;
      D.6777 = s->key;
      D.6778 = D.6776 (D.6777);
      D.6765 = hash->table_size;
      D.6779 = (unsigned int) D.6765;
      hashcode = D.6778 % D.6779;
      next = s->next;
      D.6780 = hash->table;
      D.6781 = (long unsigned int) hashcode;
      D.6782 = D.6781 * 8;
      D.6783 = D.6780 + D.6782;
      D.6784 = *D.6783;
      s->next = D.6784;
      D.6780 = hash->table;
      D.6781 = (long unsigned int) hashcode;
      D.6782 = D.6781 * 8;
      D.6783 = D.6780 + D.6782;
      *D.6783 = s;
    }
    s = next;
    <D.6453>:
    if (s != 0B) goto <D.6452>; else goto <D.6454>;
    <D.6454>:
  }
  i = i + 1;
  <D.6456>:
  if (i < current_size) goto <D.6455>; else goto <D.6457>;
  <D.6457>:
  monoeg_g_free (table);
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6481>;
      <D.6480>:
      key.2 = key;
      rv = monoeg_g_list_prepend (rv, key.2);
      <D.6481>:
      D.6786 = monoeg_g_hash_table_iter_next (&iter, &key, 0B);
      if (D.6786 != 0) goto <D.6480>; else goto <D.6482>;
      <D.6482>:
      D.6787 = monoeg_g_list_reverse (rv);
      return D.6787;
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
    }
}


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

  try
    {
      rv = 0B;
      monoeg_g_hash_table_iter_init (&iter, hash);
      goto <D.6490>;
      <D.6489>:
      value.3 = value;
      rv = monoeg_g_list_prepend (rv, value.3);
      <D.6490>:
      D.6791 = monoeg_g_hash_table_iter_next (&iter, 0B, &value);
      if (D.6791 != 0) goto <D.6489>; else goto <D.6491>;
      <D.6491>:
      D.6792 = monoeg_g_list_reverse (rv);
      return D.6792;
    }
  finally
    {
      iter = {CLOBBER};
      value = {CLOBBER};
    }
}


monoeg_g_hash_table_size (struct GHashTable * hash)
{
  guint D.6797;
  int D.6798;

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


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

  try
    {
      D.6800 = monoeg_g_hash_table_lookup_extended (hash, key, &orig_key, &value);
      if (D.6800 != 0) goto <D.6801>; else goto <D.6802>;
      <D.6801>:
      D.6803 = value;
      return D.6803;
      <D.6802>:
      D.6803 = 0B;
      return D.6803;
    }
  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.6808;
  guint (*<Tf2e>) (const void *) D.6809;
  unsigned int D.6810;
  int D.6811;
  unsigned int D.6812;
  struct Slot * * D.6813;
  long unsigned int D.6814;
  long unsigned int D.6815;
  struct Slot * * D.6816;
  void * D.6817;
  int D.6818;
  void * D.6825;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  guint hashcode;

  if (hash == 0B) goto <D.6806>; else goto <D.6807>;
  <D.6806>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 324, "hash != NULL");
  D.6808 = 0;
  return D.6808;
  <D.6807>:
  equal = hash->key_equal_func;
  D.6809 = hash->hash_func;
  D.6810 = D.6809 (key);
  D.6811 = hash->table_size;
  D.6812 = (unsigned int) D.6811;
  hashcode = D.6810 % D.6812;
  D.6813 = hash->table;
  D.6814 = (long unsigned int) hashcode;
  D.6815 = D.6814 * 8;
  D.6816 = D.6813 + D.6815;
  s = *D.6816;
  goto <D.6511>;
  <D.6510>:
  D.6817 = s->key;
  D.6818 = equal (D.6817, key);
  if (D.6818 != 0) goto <D.6819>; else goto <D.6820>;
  <D.6819>:
  if (orig_key != 0B) goto <D.6821>; else goto <D.6822>;
  <D.6821>:
  D.6817 = s->key;
  *orig_key = D.6817;
  <D.6822>:
  if (value != 0B) goto <D.6823>; else goto <D.6824>;
  <D.6823>:
  D.6825 = s->value;
  *value = D.6825;
  <D.6824>:
  D.6808 = 1;
  return D.6808;
  <D.6820>:
  s = s->next;
  <D.6511>:
  if (s != 0B) goto <D.6510>; else goto <D.6512>;
  <D.6512>:
  D.6808 = 0;
  return D.6808;
}


monoeg_g_hash_table_foreach (struct GHashTable * hash, void (*GHFunc) (void *, void *, void *) func, void * user_data)
{
  struct Slot * * D.6831;
  long unsigned int D.6832;
  long unsigned int D.6833;
  struct Slot * * D.6834;
  void * D.6835;
  void * D.6836;
  int D.6837;
  int i;

  if (hash == 0B) goto <D.6827>; else goto <D.6828>;
  <D.6827>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 347, "hash != NULL");
  return;
  <D.6828>:
  if (func == 0B) goto <D.6829>; else goto <D.6830>;
  <D.6829>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 348, "func != NULL");
  return;
  <D.6830>:
  i = 0;
  goto <D.6524>;
  <D.6523>:
  {
    struct Slot * s;

    D.6831 = hash->table;
    D.6832 = (long unsigned int) i;
    D.6833 = D.6832 * 8;
    D.6834 = D.6831 + D.6833;
    s = *D.6834;
    goto <D.6521>;
    <D.6520>:
    D.6835 = s->key;
    D.6836 = s->value;
    func (D.6835, D.6836, user_data);
    s = s->next;
    <D.6521>:
    if (s != 0B) goto <D.6520>; else goto <D.6522>;
    <D.6522>:
  }
  i = i + 1;
  <D.6524>:
  D.6837 = hash->table_size;
  if (D.6837 > i) goto <D.6523>; else goto <D.6525>;
  <D.6525>:
}


monoeg_g_hash_table_find (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) predicate, void * user_data)
{
  void * D.6841;
  struct Slot * * D.6844;
  long unsigned int D.6845;
  long unsigned int D.6846;
  struct Slot * * D.6847;
  void * D.6848;
  void * D.6849;
  int D.6850;
  int D.6853;
  int i;

  if (hash == 0B) goto <D.6839>; else goto <D.6840>;
  <D.6839>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 363, "hash != NULL");
  D.6841 = 0B;
  return D.6841;
  <D.6840>:
  if (predicate == 0B) goto <D.6842>; else goto <D.6843>;
  <D.6842>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 364, "predicate != NULL");
  D.6841 = 0B;
  return D.6841;
  <D.6843>:
  i = 0;
  goto <D.6537>;
  <D.6536>:
  {
    struct Slot * s;

    D.6844 = hash->table;
    D.6845 = (long unsigned int) i;
    D.6846 = D.6845 * 8;
    D.6847 = D.6844 + D.6846;
    s = *D.6847;
    goto <D.6534>;
    <D.6533>:
    D.6848 = s->key;
    D.6849 = s->value;
    D.6850 = predicate (D.6848, D.6849, user_data);
    if (D.6850 != 0) goto <D.6851>; else goto <D.6852>;
    <D.6851>:
    D.6841 = s->value;
    return D.6841;
    <D.6852>:
    s = s->next;
    <D.6534>:
    if (s != 0B) goto <D.6533>; else goto <D.6535>;
    <D.6535>:
  }
  i = i + 1;
  <D.6537>:
  D.6853 = hash->table_size;
  if (D.6853 > i) goto <D.6536>; else goto <D.6538>;
  <D.6538>:
  D.6841 = 0B;
  return D.6841;
}


monoeg_g_hash_table_remove_all (struct GHashTable * hash)
{
  struct Slot * * D.6857;
  long unsigned int D.6858;
  long unsigned int D.6859;
  struct Slot * * D.6860;
  void * D.6861;
  struct Slot * D.6862;
  int D.6863;
  int i;

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

    goto <D.6545>;
    <D.6544>:
    D.6857 = hash->table;
    D.6858 = (long unsigned int) i;
    D.6859 = D.6858 * 8;
    D.6860 = D.6857 + D.6859;
    s = *D.6860;
    D.6861 = s->key;
    monoeg_g_hash_table_remove (hash, D.6861);
    <D.6545>:
    D.6857 = hash->table;
    D.6858 = (long unsigned int) i;
    D.6859 = D.6858 * 8;
    D.6860 = D.6857 + D.6859;
    D.6862 = *D.6860;
    if (D.6862 != 0B) goto <D.6544>; else goto <D.6546>;
    <D.6546>:
  }
  i = i + 1;
  <D.6548>:
  D.6863 = hash->table_size;
  if (D.6863 > i) goto <D.6547>; else goto <D.6549>;
  <D.6549>:
}


monoeg_g_hash_table_remove (struct GHashTable * hash, const void * key)
{
  gboolean D.6867;
  guint (*<Tf2e>) (const void *) D.6868;
  unsigned int D.6869;
  int D.6870;
  unsigned int D.6871;
  struct Slot * * D.6872;
  long unsigned int D.6873;
  long unsigned int D.6874;
  struct Slot * * D.6875;
  void * D.6876;
  int D.6877;
  void (*<Te82>) (void *) D.6880;
  void (*<Te82>) (void *) D.6883;
  void * D.6886;
  struct Slot * D.6889;
  int D.6891;
  int D.6892;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6865>; else goto <D.6866>;
  <D.6865>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 400, "hash != NULL");
  D.6867 = 0;
  return D.6867;
  <D.6866>:
  equal = hash->key_equal_func;
  D.6868 = hash->hash_func;
  D.6869 = D.6868 (key);
  D.6870 = hash->table_size;
  D.6871 = (unsigned int) D.6870;
  hashcode = D.6869 % D.6871;
  last = 0B;
  D.6872 = hash->table;
  D.6873 = (long unsigned int) hashcode;
  D.6874 = D.6873 * 8;
  D.6875 = D.6872 + D.6874;
  s = *D.6875;
  goto <D.6559>;
  <D.6558>:
  D.6876 = s->key;
  D.6877 = equal (D.6876, key);
  if (D.6877 != 0) goto <D.6878>; else goto <D.6879>;
  <D.6878>:
  D.6880 = hash->key_destroy_func;
  if (D.6880 != 0B) goto <D.6881>; else goto <D.6882>;
  <D.6881>:
  D.6880 = hash->key_destroy_func;
  D.6876 = s->key;
  D.6880 (D.6876);
  <D.6882>:
  D.6883 = hash->value_destroy_func;
  if (D.6883 != 0B) goto <D.6884>; else goto <D.6885>;
  <D.6884>:
  D.6883 = hash->value_destroy_func;
  D.6886 = s->value;
  D.6883 (D.6886);
  <D.6885>:
  if (last == 0B) goto <D.6887>; else goto <D.6888>;
  <D.6887>:
  D.6872 = hash->table;
  D.6873 = (long unsigned int) hashcode;
  D.6874 = D.6873 * 8;
  D.6875 = D.6872 + D.6874;
  D.6889 = s->next;
  *D.6875 = D.6889;
  goto <D.6890>;
  <D.6888>:
  D.6889 = s->next;
  last->next = D.6889;
  <D.6890>:
  monoeg_g_free (s);
  D.6891 = hash->in_use;
  D.6892 = D.6891 + -1;
  hash->in_use = D.6892;
  D.6867 = 1;
  return D.6867;
  <D.6879>:
  last = s;
  s = s->next;
  <D.6559>:
  if (s != 0B) goto <D.6558>; else goto <D.6560>;
  <D.6560>:
  D.6867 = 0;
  return D.6867;
}


monoeg_g_hash_table_foreach_remove (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6896;
  struct Slot * * D.6899;
  long unsigned int D.6900;
  long unsigned int D.6901;
  struct Slot * * D.6902;
  void * D.6903;
  void * D.6904;
  int D.6905;
  void (*<Te82>) (void *) D.6908;
  void (*<Te82>) (void *) D.6911;
  struct Slot * D.6916;
  int D.6918;
  int D.6919;
  int D.6921;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6894>; else goto <D.6895>;
  <D.6894>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 433, "hash != NULL");
  D.6896 = 0;
  return D.6896;
  <D.6895>:
  if (func == 0B) goto <D.6897>; else goto <D.6898>;
  <D.6897>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 434, "func != NULL");
  D.6896 = 0;
  return D.6896;
  <D.6898>:
  i = 0;
  goto <D.6575>;
  <D.6574>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6899 = hash->table;
    D.6900 = (long unsigned int) i;
    D.6901 = D.6900 * 8;
    D.6902 = D.6899 + D.6901;
    s = *D.6902;
    goto <D.6572>;
    <D.6571>:
    D.6903 = s->key;
    D.6904 = s->value;
    D.6905 = func (D.6903, D.6904, user_data);
    if (D.6905 != 0) goto <D.6906>; else goto <D.6907>;
    <D.6906>:
    {
      struct Slot * n;

      D.6908 = hash->key_destroy_func;
      if (D.6908 != 0B) goto <D.6909>; else goto <D.6910>;
      <D.6909>:
      D.6908 = hash->key_destroy_func;
      D.6903 = s->key;
      D.6908 (D.6903);
      <D.6910>:
      D.6911 = hash->value_destroy_func;
      if (D.6911 != 0B) goto <D.6912>; else goto <D.6913>;
      <D.6912>:
      D.6911 = hash->value_destroy_func;
      D.6904 = s->value;
      D.6911 (D.6904);
      <D.6913>:
      if (last == 0B) goto <D.6914>; else goto <D.6915>;
      <D.6914>:
      D.6899 = hash->table;
      D.6900 = (long unsigned int) i;
      D.6901 = D.6900 * 8;
      D.6902 = D.6899 + D.6901;
      D.6916 = s->next;
      *D.6902 = D.6916;
      n = s->next;
      goto <D.6917>;
      <D.6915>:
      D.6916 = s->next;
      last->next = D.6916;
      n = last->next;
      <D.6917>:
      monoeg_g_free (s);
      D.6918 = hash->in_use;
      D.6919 = D.6918 + -1;
      hash->in_use = D.6919;
      count = count + 1;
      s = n;
    }
    goto <D.6920>;
    <D.6907>:
    last = s;
    s = s->next;
    <D.6920>:
    <D.6572>:
    if (s != 0B) goto <D.6571>; else goto <D.6573>;
    <D.6573>:
  }
  i = i + 1;
  <D.6575>:
  D.6921 = hash->table_size;
  if (D.6921 > i) goto <D.6574>; else goto <D.6576>;
  <D.6576>:
  if (count > 0) goto <D.6922>; else goto <D.6923>;
  <D.6922>:
  rehash (hash);
  <D.6923>:
  D.6896 = (guint) count;
  return D.6896;
}


monoeg_g_hash_table_steal (struct GHashTable * hash, const void * key)
{
  gboolean D.6927;
  guint (*<Tf2e>) (const void *) D.6928;
  unsigned int D.6929;
  int D.6930;
  unsigned int D.6931;
  struct Slot * * D.6932;
  long unsigned int D.6933;
  long unsigned int D.6934;
  struct Slot * * D.6935;
  void * D.6936;
  int D.6937;
  struct Slot * D.6942;
  int D.6944;
  int D.6945;
  gboolean (*GEqualFunc) (const void *, const void *) equal;
  struct Slot * s;
  struct Slot * last;
  guint hashcode;

  if (hash == 0B) goto <D.6925>; else goto <D.6926>;
  <D.6925>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 479, "hash != NULL");
  D.6927 = 0;
  return D.6927;
  <D.6926>:
  equal = hash->key_equal_func;
  D.6928 = hash->hash_func;
  D.6929 = D.6928 (key);
  D.6930 = hash->table_size;
  D.6931 = (unsigned int) D.6930;
  hashcode = D.6929 % D.6931;
  last = 0B;
  D.6932 = hash->table;
  D.6933 = (long unsigned int) hashcode;
  D.6934 = D.6933 * 8;
  D.6935 = D.6932 + D.6934;
  s = *D.6935;
  goto <D.6586>;
  <D.6585>:
  D.6936 = s->key;
  D.6937 = equal (D.6936, key);
  if (D.6937 != 0) goto <D.6938>; else goto <D.6939>;
  <D.6938>:
  if (last == 0B) goto <D.6940>; else goto <D.6941>;
  <D.6940>:
  D.6932 = hash->table;
  D.6933 = (long unsigned int) hashcode;
  D.6934 = D.6933 * 8;
  D.6935 = D.6932 + D.6934;
  D.6942 = s->next;
  *D.6935 = D.6942;
  goto <D.6943>;
  <D.6941>:
  D.6942 = s->next;
  last->next = D.6942;
  <D.6943>:
  monoeg_g_free (s);
  D.6944 = hash->in_use;
  D.6945 = D.6944 + -1;
  hash->in_use = D.6945;
  D.6927 = 1;
  return D.6927;
  <D.6939>:
  last = s;
  s = s->next;
  <D.6586>:
  if (s != 0B) goto <D.6585>; else goto <D.6587>;
  <D.6587>:
  D.6927 = 0;
  return D.6927;
}


monoeg_g_hash_table_foreach_steal (struct GHashTable * hash, gboolean (*GHRFunc) (void *, void *, void *) func, void * user_data)
{
  guint D.6949;
  struct Slot * * D.6952;
  long unsigned int D.6953;
  long unsigned int D.6954;
  struct Slot * * D.6955;
  void * D.6956;
  void * D.6957;
  int D.6958;
  struct Slot * D.6963;
  int D.6965;
  int D.6966;
  int D.6968;
  int i;
  int count;

  count = 0;
  if (hash == 0B) goto <D.6947>; else goto <D.6948>;
  <D.6947>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 509, "hash != NULL");
  D.6949 = 0;
  return D.6949;
  <D.6948>:
  if (func == 0B) goto <D.6950>; else goto <D.6951>;
  <D.6950>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "ghashtable.c", 510, "func != NULL");
  D.6949 = 0;
  return D.6949;
  <D.6951>:
  i = 0;
  goto <D.6602>;
  <D.6601>:
  {
    struct Slot * s;
    struct Slot * last;

    last = 0B;
    D.6952 = hash->table;
    D.6953 = (long unsigned int) i;
    D.6954 = D.6953 * 8;
    D.6955 = D.6952 + D.6954;
    s = *D.6955;
    goto <D.6599>;
    <D.6598>:
    D.6956 = s->key;
    D.6957 = s->value;
    D.6958 = func (D.6956, D.6957, user_data);
    if (D.6958 != 0) goto <D.6959>; else goto <D.6960>;
    <D.6959>:
    {
      struct Slot * n;

      if (last == 0B) goto <D.6961>; else goto <D.6962>;
      <D.6961>:
      D.6952 = hash->table;
      D.6953 = (long unsigned int) i;
      D.6954 = D.6953 * 8;
      D.6955 = D.6952 + D.6954;
      D.6963 = s->next;
      *D.6955 = D.6963;
      n = s->next;
      goto <D.6964>;
      <D.6962>:
      D.6963 = s->next;
      last->next = D.6963;
      n = last->next;
      <D.6964>:
      monoeg_g_free (s);
      D.6965 = hash->in_use;
      D.6966 = D.6965 + -1;
      hash->in_use = D.6966;
      count = count + 1;
      s = n;
    }
    goto <D.6967>;
    <D.6960>:
    last = s;
    s = s->next;
    <D.6967>:
    <D.6599>:
    if (s != 0B) goto <D.6598>; else goto <D.6600>;
    <D.6600>:
  }
  i = i + 1;
  <D.6602>:
  D.6968 = hash->table_size;
  if (D.6968 > i) goto <D.6601>; else goto <D.6603>;
  <D.6603>:
  if (count > 0) goto <D.6969>; else goto <D.6970>;
  <D.6969>:
  rehash (hash);
  <D.6970>:
  D.6949 = (guint) count;
  return D.6949;
}


monoeg_g_hash_table_destroy (struct GHashTable * hash)
{
  struct Slot * * D.6974;
  long unsigned int D.6975;
  long unsigned int D.6976;
  struct Slot * * D.6977;
  void (*<Te82>) (void *) D.6978;
  void * D.6981;
  void (*<Te82>) (void *) D.6982;
  void * D.6985;
  int D.6986;
  int i;

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

    D.6974 = hash->table;
    D.6975 = (long unsigned int) i;
    D.6976 = D.6975 * 8;
    D.6977 = D.6974 + D.6976;
    s = *D.6977;
    goto <D.6611>;
    <D.6610>:
    next = s->next;
    D.6978 = hash->key_destroy_func;
    if (D.6978 != 0B) goto <D.6979>; else goto <D.6980>;
    <D.6979>:
    D.6978 = hash->key_destroy_func;
    D.6981 = s->key;
    D.6978 (D.6981);
    <D.6980>:
    D.6982 = hash->value_destroy_func;
    if (D.6982 != 0B) goto <D.6983>; else goto <D.6984>;
    <D.6983>:
    D.6982 = hash->value_destroy_func;
    D.6985 = s->value;
    D.6982 (D.6985);
    <D.6984>:
    monoeg_g_free (s);
    s = next;
    <D.6611>:
    if (s != 0B) goto <D.6610>; else goto <D.6612>;
    <D.6612>:
  }
  i = i + 1;
  <D.6614>:
  D.6986 = hash->table_size;
  if (D.6986 > i) goto <D.6613>; else goto <D.6615>;
  <D.6615>:
  D.6974 = hash->table;
  monoeg_g_free (D.6974);
  monoeg_g_free (hash);
}


monoeg_g_hash_table_print_stats (struct GHashTable * table)
{
  struct Slot * * D.6988;
  long unsigned int D.6989;
  long unsigned int D.6990;
  struct Slot * * D.6991;
  int D.6994;
  int D.6995;
  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.6628>;
  <D.6627>:
  chain_size = 0;
  D.6988 = table->table;
  D.6989 = (long unsigned int) i;
  D.6990 = D.6989 * 8;
  D.6991 = D.6988 + D.6990;
  node = *D.6991;
  goto <D.6625>;
  <D.6624>:
  chain_size = chain_size + 1;
  node = node->next;
  <D.6625>:
  if (node != 0B) goto <D.6624>; else goto <D.6626>;
  <D.6626>:
  if (chain_size > max_chain_size) goto <D.6992>; else goto <D.6993>;
  <D.6992>:
  max_chain_size = chain_size;
  max_chain_index = i;
  <D.6993>:
  i = i + 1;
  <D.6628>:
  D.6994 = table->table_size;
  if (D.6994 > i) goto <D.6627>; else goto <D.6629>;
  <D.6629>:
  D.6995 = table->in_use;
  D.6994 = table->table_size;
  printf ("Size: %d Table Size: %d Max Chain Length: %d at %d\n", D.6995, D.6994, max_chain_size, max_chain_index);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.6996;

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


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

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.6998;
  long unsigned int D.6999;

  D.6999 = __builtin_object_size (__dest, 0);
  D.6998 = __builtin___memset_chk (__dest, __ch, __len, D.6999);
  return D.6998;
}


monoeg_g_hash_table_iter_next (struct GHashTableIter * it, void * * key, void * * value)
{
  int D.7001;
  _Bool D.7002;
  long int D.7003;
  long int D.7004;
  struct Slot * D.7009;
  int D.7012;
  int D.7013;
  gboolean D.7016;
  struct Slot * * D.7017;
  long unsigned int D.7018;
  long unsigned int D.7019;
  struct Slot * * D.7020;
  struct Slot * D.7021;
  void * D.7025;
  void * D.7028;
  struct Slot * D.7029;
  struct Iter * iter;
  struct GHashTable * hash;

  iter = it;
  hash = iter->ht;
  D.7001 = iter->slot_index;
  D.7002 = D.7001 == -2;
  D.7003 = (long int) D.7002;
  D.7004 = __builtin_expect (D.7003, 0);
  if (D.7004 != 0) goto <D.7005>; else goto <D.7006>;
  <D.7005>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 606, "iter->slot_index != -2");
  <D.7006>:
  if (0 != 0) goto <D.7007>; else goto <D.7008>;
  <D.7007>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ghashtable.c", 607, "sizeof (Iter) <= sizeof (GHashTableIter)");
  <D.7008>:
  D.7009 = iter->slot;
  if (D.7009 == 0B) goto <D.7010>; else goto <D.7011>;
  <D.7010>:
  <D.6643>:
  D.7001 = iter->slot_index;
  D.7012 = D.7001 + 1;
  iter->slot_index = D.7012;
  D.7001 = iter->slot_index;
  D.7013 = hash->table_size;
  if (D.7001 >= D.7013) goto <D.7014>; else goto <D.7015>;
  <D.7014>:
  iter->slot_index = -2;
  D.7016 = 0;
  return D.7016;
  <D.7015>:
  D.7017 = hash->table;
  D.7001 = iter->slot_index;
  D.7018 = (long unsigned int) D.7001;
  D.7019 = D.7018 * 8;
  D.7020 = D.7017 + D.7019;
  D.7021 = *D.7020;
  if (D.7021 != 0B) goto <D.6642>; else goto <D.7022>;
  <D.7022>:
  goto <D.6643>;
  <D.6642>:
  D.7017 = hash->table;
  D.7001 = iter->slot_index;
  D.7018 = (long unsigned int) D.7001;
  D.7019 = D.7018 * 8;
  D.7020 = D.7017 + D.7019;
  D.7021 = *D.7020;
  iter->slot = D.7021;
  <D.7011>:
  if (key != 0B) goto <D.7023>; else goto <D.7024>;
  <D.7023>:
  D.7009 = iter->slot;
  D.7025 = D.7009->key;
  *key = D.7025;
  <D.7024>:
  if (value != 0B) goto <D.7026>; else goto <D.7027>;
  <D.7026>:
  D.7009 = iter->slot;
  D.7028 = D.7009->value;
  *value = D.7028;
  <D.7027>:
  D.7009 = iter->slot;
  D.7029 = D.7009->next;
  iter->slot = D.7029;
  D.7016 = 1;
  return D.7016;
}


monoeg_g_direct_equal (const void * v1, const void * v2)
{
  gboolean D.7031;
  _Bool D.7032;

  D.7032 = v1 == v2;
  D.7031 = (gboolean) D.7032;
  return D.7031;
}


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

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


monoeg_g_int_equal (const void * v1, const void * v2)
{
  gboolean D.7037;
  int D.7038;
  int D.7039;
  _Bool D.7040;

  D.7038 = MEM[(gint *)v1];
  D.7039 = MEM[(gint *)v2];
  D.7040 = D.7038 == D.7039;
  D.7037 = (gboolean) D.7040;
  return D.7037;
}


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

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


monoeg_g_str_equal (const void * v1, const void * v2)
{
  gboolean D.7044;
  int D.6670;
  _Bool D.7045;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.6670 = __builtin_strcmp (v1, v2);
  }
  D.7045 = D.6670 == 0;
  D.7044 = (gboolean) D.7045;
  return D.7044;
}


monoeg_g_str_hash (const void * v1)
{
  unsigned int D.7047;
  char D.7048;
  unsigned int D.7049;
  unsigned int D.7050;
  char * p.5;
  char D.7052;
  guint D.7053;
  guint hash;
  char * p;

  hash = 0;
  p = v1;
  goto <D.6677>;
  <D.6676>:
  D.7047 = hash << 5;
  D.7048 = *p;
  D.7049 = (unsigned int) D.7048;
  D.7050 = D.7049 + hash;
  hash = D.7047 - D.7050;
  <D.6677>:
  p.5 = p;
  p = p.5 + 1;
  D.7052 = *p.5;
  if (D.7052 != 0) goto <D.6676>; else goto <D.6678>;
  <D.6678>:
  D.7053 = hash;
  return D.7053;
}