monoeg_g_strndup (const gchar * str, gsize n)
{
  gchar * D.7588;

  D.7588 = __strndup (str, n);
  return D.7588;
}


monoeg_g_strfreev (gchar * * str_array)
{
  gchar * D.7592;
  gchar * * orig;

  orig = str_array;
  if (str_array == 0B) goto <D.7590>; else goto <D.7591>;
  <D.7590>:
  return;
  <D.7591>:
  goto <D.7190>;
  <D.7189>:
  D.7592 = *str_array;
  monoeg_g_free (D.7592);
  str_array = str_array + 4;
  <D.7190>:
  D.7592 = *str_array;
  if (D.7592 != 0B) goto <D.7189>; else goto <D.7191>;
  <D.7191>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.7596;
  unsigned int D.7597;
  unsigned int D.7598;
  unsigned int D.7599;
  gchar * * D.7600;
  gchar * * D.7601;
  gchar * D.7602;
  gchar * D.7603;
  unsigned int D.7604;
  gchar * * D.7605;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.7594>; else goto <D.7595>;
  <D.7594>:
  D.7596 = 0B;
  return D.7596;
  <D.7595>:
  length = monoeg_g_strv_length (str_array);
  D.7597 = length + 1;
  D.7598 = D.7597 * 4;
  ret = monoeg_malloc0 (D.7598);
  i = 0;
  goto <D.7199>;
  <D.7198>:
  D.7599 = i * 4;
  D.7600 = ret + D.7599;
  D.7599 = i * 4;
  D.7601 = str_array + D.7599;
  D.7602 = *D.7601;
  D.7603 = monoeg_strdup (D.7602);
  *D.7600 = D.7603;
  i = i + 1;
  <D.7199>:
  D.7599 = i * 4;
  D.7601 = str_array + D.7599;
  D.7602 = *D.7601;
  if (D.7602 != 0B) goto <D.7198>; else goto <D.7200>;
  <D.7200>:
  D.7604 = length * 4;
  D.7605 = ret + D.7604;
  *D.7605 = 0B;
  D.7596 = ret;
  return D.7596;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.7609;

  if (str != 0B) goto <D.7607>; else goto <D.7608>;
  <D.7607>:
  D.7609 = __strdup (str);
  return D.7609;
  <D.7608>:
  D.7609 = 0B;
  return D.7609;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.7613;
  unsigned int length.0;
  unsigned int D.7615;
  gchar * * D.7616;
  gchar * D.7617;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.7611>; else goto <D.7612>;
  <D.7611>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.7613 = 0;
  return D.7613;
  <D.7612>:
  length = 0;
  goto <D.7206>;
  <D.7205>:
  length = length + 1;
  <D.7206>:
  length.0 = (unsigned int) length;
  D.7615 = length.0 * 4;
  D.7616 = str_array + D.7615;
  D.7617 = *D.7616;
  if (D.7617 != 0B) goto <D.7205>; else goto <D.7207>;
  <D.7207>:
  D.7613 = (guint) length;
  return D.7613;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.7621;
  int iftmp.1;
  sizetype D.7628;
  const gchar * D.7629;
  int D.7630;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.7619>; else goto <D.7620>;
  <D.7619>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.7621 = 0;
  return D.7621;
  <D.7620>:
  if (suffix == 0B) goto <D.7622>; else goto <D.7623>;
  <D.7622>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.7621 = 0;
  return D.7621;
  <D.7623>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.7627>; else goto <D.7625>;
  <D.7627>:
  D.7628 = str_length - suffix_length;
  D.7629 = str + D.7628;
  D.7630 = strncmp (D.7629, suffix, suffix_length);
  if (D.7630 == 0) goto <D.7631>; else goto <D.7625>;
  <D.7631>:
  iftmp.1 = 1;
  goto <D.7626>;
  <D.7625>:
  iftmp.1 = 0;
  <D.7626>:
  D.7621 = iftmp.1;
  return D.7621;
}


monoeg_g_str_has_prefix (const gchar * str, const gchar * prefix)
{
  gboolean D.7635;
  int iftmp.2;
  int D.7642;
  size_t str_length;
  size_t prefix_length;

  if (str == 0B) goto <D.7633>; else goto <D.7634>;
  <D.7633>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.7635 = 0;
  return D.7635;
  <D.7634>:
  if (prefix == 0B) goto <D.7636>; else goto <D.7637>;
  <D.7636>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.7635 = 0;
  return D.7635;
  <D.7637>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.7641>; else goto <D.7639>;
  <D.7641>:
  D.7642 = strncmp (str, prefix, prefix_length);
  if (D.7642 == 0) goto <D.7643>; else goto <D.7639>;
  <D.7643>:
  iftmp.2 = 1;
  goto <D.7640>;
  <D.7639>:
  iftmp.2 = 0;
  <D.7640>:
  D.7635 = iftmp.2;
  return D.7635;
}


monoeg_g_strdup_vprintf (const gchar * format, struct va_list args)
{
  gchar * D.7647;
  int n;
  char * ret;

  try
    {
      n = vasprintf (&ret, format, args);
      if (n == -1) goto <D.7645>; else goto <D.7646>;
      <D.7645>:
      D.7647 = 0B;
      return D.7647;
      <D.7646>:
      D.7647 = ret;
      return D.7647;
    }
  finally
    {
      ret = {CLOBBER};
    }
}


vasprintf (char * * restrict __ptr, const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.7650;

  D.7650 = __vasprintf_chk (__ptr, 1, __fmt, __ap);
  return D.7650;
}


monoeg_g_strdup_printf (const gchar * format)
{
  gchar * D.7654;
  gchar * ret;
  struct va_list args;
  int n;

  try
    {
      __builtin_va_start (&args, 0);
      n = vasprintf (&ret, format, args);
      __builtin_va_end (&args);
      if (n == -1) goto <D.7652>; else goto <D.7653>;
      <D.7652>:
      D.7654 = 0B;
      return D.7654;
      <D.7653>:
      D.7654 = ret;
      return D.7654;
    }
  finally
    {
      ret = {CLOBBER};
      args = {CLOBBER};
    }
}


monoeg_g_strerror (gint errnum)
{
  const gchar * D.7657;

  D.7657 = strerror (errnum);
  return D.7657;
}


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.7661;
  unsigned int D.7662;
  void * D.7663;
  void * D.7664;
  unsigned int D.7665;
  void * D.7666;
  void * D.7667;
  unsigned int D.7668;
  char * D.7671;
  void * D.7672;
  void * D.7673;
  void * D.7674;
  void * D.7675;
  struct va_list args;
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.7659>; else goto <D.7660>;
      <D.7659>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.7661 = 0B;
      return D.7661;
      <D.7660>:
      D.7662 = strlen (first);
      total = D.7662 + total;
      __builtin_va_start (&args, 0);
      D.7663 = args.__ap;
      D.7664 = D.7663 + 4;
      args.__ap = D.7664;
      s = MEM[(char * *)D.7663];
      goto <D.7261>;
      <D.7260>:
      D.7665 = strlen (s);
      total = D.7665 + total;
      D.7666 = args.__ap;
      D.7667 = D.7666 + 4;
      args.__ap = D.7667;
      s = MEM[(char * *)D.7666];
      <D.7261>:
      if (s != 0B) goto <D.7260>; else goto <D.7262>;
      <D.7262>:
      __builtin_va_end (&args);
      D.7668 = total + 1;
      ret = monoeg_malloc (D.7668);
      if (ret == 0B) goto <D.7669>; else goto <D.7670>;
      <D.7669>:
      D.7661 = 0B;
      return D.7661;
      <D.7670>:
      D.7671 = ret + total;
      *D.7671 = 0;
      strcpy (ret, first);
      __builtin_va_start (&args, 0);
      D.7672 = args.__ap;
      D.7673 = D.7672 + 4;
      args.__ap = D.7673;
      s = MEM[(char * *)D.7672];
      goto <D.7264>;
      <D.7263>:
      strcat (ret, s);
      D.7674 = args.__ap;
      D.7675 = D.7674 + 4;
      args.__ap = D.7675;
      s = MEM[(char * *)D.7674];
      <D.7264>:
      if (s != 0B) goto <D.7263>; else goto <D.7265>;
      <D.7265>:
      __builtin_va_end (&args);
      D.7661 = ret;
      return D.7661;
    }
  finally
    {
      args = {CLOBBER};
    }
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.7678;
  unsigned int D.7679;

  D.7679 = __builtin_object_size (__dest, 1);
  D.7678 = __builtin___strcpy_chk (__dest, __src, D.7679);
  return D.7678;
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.7681;
  unsigned int D.7682;

  D.7682 = __builtin_object_size (__dest, 1);
  D.7681 = __builtin___strcat_chk (__dest, __src, D.7682);
  return D.7681;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.7686;
  char D.7689;
  unsigned int D.7692;
  int D.7693;
  void * vector.3;
  gchar * * vector.4;
  gchar * D.7698;
  unsigned int D.7699;
  unsigned int D.7701;
  int D.7702;
  unsigned int D.7705;
  char D.7707;
  unsigned int D.7709;
  int D.7710;
  int string.5;
  int c.6;
  int D.7715;
  int D.7319;
  unsigned int D.7718;
  _Bool D.7721;
  _Bool D.7722;
  _Bool D.7723;
  int D.7331;
  gchar * D.7728;
  gchar * D.7730;
  void * vector.7;
  sizetype size.8;
  sizetype D.7738;
  sizetype D.7739;
  gchar * * D.7740;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.7684>; else goto <D.7685>;
      <D.7684>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.7686 = 0B;
      return D.7686;
      <D.7685>:
      if (delimiter == 0B) goto <D.7687>; else goto <D.7688>;
      <D.7687>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.7686 = 0B;
      return D.7686;
      <D.7688>:
      D.7689 = *delimiter;
      if (D.7689 == 0) goto <D.7690>; else goto <D.7691>;
      <D.7690>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.7686 = 0B;
      return D.7686;
      <D.7691>:
      D.7692 = strlen (delimiter);
      D.7693 = strncmp (string, delimiter, D.7692);
      if (D.7693 == 0) goto <D.7694>; else goto <D.7695>;
      <D.7694>:
      vector.3 = monoeg_malloc (8);
      vector = vector.3;
      vector.4 = vector;
      D.7698 = monoeg_strdup ("");
      *vector.4 = D.7698;
      size = size + 1;
      D.7699 = strlen (delimiter);
      string = string + D.7699;
      goto <D.7700>;
      <D.7695>:
      vector = 0B;
      <D.7700>:
      goto <D.7321>;
      <D.7320>:
      c = string;
      D.7701 = strlen (delimiter);
      D.7702 = strncmp (string, delimiter, D.7701);
      if (D.7702 == 0) goto <D.7703>; else goto <D.7704>;
      <D.7703>:
      token = monoeg_strdup ("");
      D.7705 = strlen (delimiter);
      string = string + D.7705;
      goto <D.7706>;
      <D.7704>:
      goto <D.7308>;
      <D.7307>:
      string = string + 1;
      <D.7308>:
      D.7707 = *string;
      if (D.7707 != 0) goto <D.7708>; else goto <D.7309>;
      <D.7708>:
      D.7709 = strlen (delimiter);
      D.7710 = strncmp (string, delimiter, D.7709);
      if (D.7710 != 0) goto <D.7307>; else goto <D.7309>;
      <D.7309>:
      D.7707 = *string;
      if (D.7707 != 0) goto <D.7711>; else goto <D.7712>;
      <D.7711>:
      {
        gsize toklen;

        string.5 = (int) string;
        c.6 = (int) c;
        D.7715 = string.5 - c.6;
        toklen = (gsize) D.7715;
        token = monoeg_g_strndup (c, toklen);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.7319 = __builtin_strcmp (string, delimiter);
        }
        if (D.7319 != 0) goto <D.7716>; else goto <D.7717>;
        <D.7716>:
        D.7718 = strlen (delimiter);
        string = string + D.7718;
        <D.7717>:
      }
      goto <D.7719>;
      <D.7712>:
      token = monoeg_strdup (c);
      <D.7719>:
      <D.7706>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.7321>:
      D.7707 = *string;
      if (D.7707 != 0) goto <D.7720>; else goto <D.7322>;
      <D.7720>:
      D.7721 = max_tokens <= 0;
      D.7722 = size < max_tokens;
      D.7723 = D.7721 | D.7722;
      if (D.7723 != 0) goto <D.7320>; else goto <D.7322>;
      <D.7322>:
      D.7707 = *string;
      if (D.7707 != 0) goto <D.7724>; else goto <D.7725>;
      <D.7724>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.7331 = __builtin_strcmp (string, delimiter);
      }
      if (D.7331 == 0) goto <D.7726>; else goto <D.7727>;
      <D.7726>:
      D.7728 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.7728);
      goto <D.7729>;
      <D.7727>:
      D.7730 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.7730);
      <D.7729>:
      size = size + 1;
      <D.7725>:
      vector.4 = vector;
      if (vector.4 == 0B) goto <D.7731>; else goto <D.7732>;
      <D.7731>:
      vector.7 = monoeg_malloc (8);
      vector = vector.7;
      vector.4 = vector;
      *vector.4 = 0B;
      goto <D.7734>;
      <D.7732>:
      if (size > 0) goto <D.7735>; else goto <D.7736>;
      <D.7735>:
      vector.4 = vector;
      size.8 = (sizetype) size;
      D.7738 = size.8 + 1073741823;
      D.7739 = D.7738 * 4;
      D.7740 = vector.4 + D.7739;
      *D.7740 = 0B;
      <D.7736>:
      <D.7734>:
      D.7686 = vector;
      return D.7686;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.9;
  gchar * * D.7744;
  int D.7748;
  unsigned int D.7749;
  unsigned int D.7750;
  sizetype size.10;
  sizetype D.7752;
  sizetype D.7753;
  gchar * * D.7754;

  D.7744 = *vector;
  if (D.7744 == 0B) goto <D.7745>; else goto <D.7746>;
  <D.7745>:
  iftmp.9 = monoeg_malloc (8);
  goto <D.7747>;
  <D.7746>:
  D.7744 = *vector;
  D.7748 = size + 1;
  D.7749 = (unsigned int) D.7748;
  D.7750 = D.7749 * 4;
  iftmp.9 = monoeg_realloc (D.7744, D.7750);
  <D.7747>:
  *vector = iftmp.9;
  D.7744 = *vector;
  size.10 = (sizetype) size;
  D.7752 = size.10 + 1073741823;
  D.7753 = D.7752 * 4;
  D.7754 = D.7744 + D.7753;
  *D.7754 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.7757;
  char D.7760;
  char D.7763;
  int D.7764;
  void * vector.11;
  gchar * * vector.12;
  gchar * D.7769;
  int D.7771;
  int string.13;
  int c.14;
  int D.7776;
  _Bool D.7781;
  _Bool D.7782;
  _Bool D.7783;
  _Bool D.7784;
  _Bool D.7785;
  _Bool D.7786;
  gchar * D.7791;
  char D.7793;
  gchar * D.7796;
  gchar * D.7798;
  void * vector.15;
  sizetype size.16;
  sizetype D.7806;
  sizetype D.7807;
  gchar * * D.7808;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.7755>; else goto <D.7756>;
      <D.7755>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.7757 = 0B;
      return D.7757;
      <D.7756>:
      if (delimiter == 0B) goto <D.7758>; else goto <D.7759>;
      <D.7758>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.7757 = 0B;
      return D.7757;
      <D.7759>:
      D.7760 = *delimiter;
      if (D.7760 == 0) goto <D.7761>; else goto <D.7762>;
      <D.7761>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.7757 = 0B;
      return D.7757;
      <D.7762>:
      D.7763 = *string;
      D.7764 = charcmp (D.7763, delimiter);
      if (D.7764 != 0) goto <D.7765>; else goto <D.7766>;
      <D.7765>:
      vector.11 = monoeg_malloc (8);
      vector = vector.11;
      vector.12 = vector;
      D.7769 = monoeg_strdup ("");
      *vector.12 = D.7769;
      size = size + 1;
      string = string + 1;
      goto <D.7770>;
      <D.7766>:
      vector = 0B;
      <D.7770>:
      c = string;
      goto <D.7350>;
      <D.7349>:
      D.7763 = *string;
      D.7771 = charcmp (D.7763, delimiter);
      if (D.7771 != 0) goto <D.7772>; else goto <D.7773>;
      <D.7772>:
      {
        gsize toklen;

        string.13 = (int) string;
        c.14 = (int) c;
        D.7776 = string.13 - c.14;
        toklen = (gsize) D.7776;
        if (toklen == 0) goto <D.7777>; else goto <D.7778>;
        <D.7777>:
        token = monoeg_strdup ("");
        goto <D.7779>;
        <D.7778>:
        token = monoeg_g_strndup (c, toklen);
        <D.7779>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.7773>:
      string = string + 1;
      <D.7350>:
      D.7763 = *string;
      if (D.7763 != 0) goto <D.7780>; else goto <D.7351>;
      <D.7780>:
      D.7781 = max_tokens <= 0;
      D.7782 = size < max_tokens;
      D.7783 = D.7781 | D.7782;
      if (D.7783 != 0) goto <D.7349>; else goto <D.7351>;
      <D.7351>:
      D.7784 = max_tokens > 0;
      D.7785 = size >= max_tokens;
      D.7786 = D.7784 & D.7785;
      if (D.7786 != 0) goto <D.7787>; else goto <D.7788>;
      <D.7787>:
      D.7763 = *string;
      if (D.7763 != 0) goto <D.7789>; else goto <D.7790>;
      <D.7789>:
      D.7791 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.7791);
      size = size + 1;
      <D.7790>:
      goto <D.7792>;
      <D.7788>:
      D.7793 = *c;
      if (D.7793 != 0) goto <D.7794>; else goto <D.7795>;
      <D.7794>:
      D.7796 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.7796);
      size = size + 1;
      goto <D.7797>;
      <D.7795>:
      D.7798 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.7798);
      size = size + 1;
      <D.7797>:
      <D.7792>:
      vector.12 = vector;
      if (vector.12 == 0B) goto <D.7799>; else goto <D.7800>;
      <D.7799>:
      vector.15 = monoeg_malloc (8);
      vector = vector.15;
      vector.12 = vector;
      *vector.12 = 0B;
      goto <D.7802>;
      <D.7800>:
      if (size > 0) goto <D.7803>; else goto <D.7804>;
      <D.7803>:
      vector.12 = vector;
      size.16 = (sizetype) size;
      D.7806 = size.16 + 1073741823;
      D.7807 = D.7806 * 4;
      D.7808 = vector.12 + D.7807;
      *D.7808 = 0B;
      <D.7804>:
      <D.7802>:
      D.7757 = vector;
      return D.7757;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.7811;
  gboolean D.7814;

  goto <D.7337>;
  <D.7336>:
  D.7811 = *compare;
  if (D.7811 == testchar) goto <D.7812>; else goto <D.7813>;
  <D.7812>:
  D.7814 = 1;
  return D.7814;
  <D.7813>:
  compare = compare + 1;
  <D.7337>:
  D.7811 = *compare;
  if (D.7811 != 0) goto <D.7336>; else goto <D.7338>;
  <D.7338>:
  D.7814 = 0;
  return D.7814;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.7818;
  char D.7819;
  unsigned int D.7822;
  gchar * D.7823;
  gchar * D.7824;
  char D.7825;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.7816>; else goto <D.7817>;
  <D.7816>:
  D.7818 = 0B;
  return D.7818;
  <D.7817>:
  D.7819 = *str;
  if (D.7819 == 0) goto <D.7820>; else goto <D.7821>;
  <D.7820>:
  D.7818 = str;
  return D.7818;
  <D.7821>:
  i = 0;
  D.7822 = strlen (str);
  j = D.7822 + 4294967295;
  goto <D.7359>;
  <D.7358>:
  D.7823 = str + i;
  c = *D.7823;
  D.7823 = str + i;
  D.7824 = str + j;
  D.7825 = *D.7824;
  *D.7823 = D.7825;
  D.7824 = str + j;
  *D.7824 = c;
  i = i + 1;
  j = j + 4294967295;
  <D.7359>:
  if (i < j) goto <D.7358>; else goto <D.7360>;
  <D.7360>:
  D.7818 = str;
  return D.7818;
}


monoeg_g_strjoin (const gchar * separator)
{
  void * D.7830;
  void * D.7831;
  unsigned int D.7832;
  void * D.7833;
  void * D.7834;
  gchar * D.7837;
  _Bool D.7838;
  _Bool D.7839;
  _Bool D.7840;
  unsigned int D.7843;
  void * D.7844;
  void * D.7845;
  void * D.7846;
  void * D.7847;
  void * D.7850;
  void * D.7851;
  struct va_list args;
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.7827>; else goto <D.7828>;
      <D.7827>:
      slen = strlen (separator);
      goto <D.7829>;
      <D.7828>:
      slen = 0;
      <D.7829>:
      len = 0;
      __builtin_va_start (&args, 0);
      D.7830 = args.__ap;
      D.7831 = D.7830 + 4;
      args.__ap = D.7831;
      s = MEM[(char * *)D.7830];
      goto <D.7371>;
      <D.7370>:
      D.7832 = strlen (s);
      len = D.7832 + len;
      len = len + slen;
      D.7833 = args.__ap;
      D.7834 = D.7833 + 4;
      args.__ap = D.7834;
      s = MEM[(char * *)D.7833];
      <D.7371>:
      if (s != 0B) goto <D.7370>; else goto <D.7372>;
      <D.7372>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.7835>; else goto <D.7836>;
      <D.7835>:
      D.7837 = monoeg_strdup ("");
      return D.7837;
      <D.7836>:
      D.7838 = slen != 0;
      D.7839 = len != 0;
      D.7840 = D.7838 & D.7839;
      if (D.7840 != 0) goto <D.7841>; else goto <D.7842>;
      <D.7841>:
      len = len - slen;
      <D.7842>:
      D.7843 = len + 1;
      res = monoeg_malloc (D.7843);
      __builtin_va_start (&args, 0);
      D.7844 = args.__ap;
      D.7845 = D.7844 + 4;
      args.__ap = D.7845;
      s = MEM[(char * *)D.7844];
      r = monoeg_g_stpcpy (res, s);
      D.7846 = args.__ap;
      D.7847 = D.7846 + 4;
      args.__ap = D.7847;
      s = MEM[(char * *)D.7846];
      goto <D.7374>;
      <D.7373>:
      if (separator != 0B) goto <D.7848>; else goto <D.7849>;
      <D.7848>:
      r = monoeg_g_stpcpy (r, separator);
      <D.7849>:
      r = monoeg_g_stpcpy (r, s);
      D.7850 = args.__ap;
      D.7851 = D.7850 + 4;
      args.__ap = D.7851;
      s = MEM[(char * *)D.7850];
      <D.7374>:
      if (s != 0B) goto <D.7373>; else goto <D.7375>;
      <D.7375>:
      __builtin_va_end (&args);
      D.7837 = res;
      return D.7837;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  unsigned int D.7857;
  gchar * * D.7858;
  gchar * D.7859;
  unsigned int D.7860;
  gchar * D.7863;
  _Bool D.7864;
  _Bool D.7865;
  _Bool D.7866;
  unsigned int D.7869;
  gchar * D.7870;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.7854>; else goto <D.7855>;
  <D.7854>:
  slen = strlen (separator);
  goto <D.7856>;
  <D.7855>:
  slen = 0;
  <D.7856>:
  len = 0;
  i = 0;
  goto <D.7386>;
  <D.7385>:
  D.7857 = i * 4;
  D.7858 = str_array + D.7857;
  D.7859 = *D.7858;
  D.7860 = strlen (D.7859);
  len = D.7860 + len;
  len = len + slen;
  i = i + 1;
  <D.7386>:
  D.7857 = i * 4;
  D.7858 = str_array + D.7857;
  D.7859 = *D.7858;
  if (D.7859 != 0B) goto <D.7385>; else goto <D.7387>;
  <D.7387>:
  if (len == 0) goto <D.7861>; else goto <D.7862>;
  <D.7861>:
  D.7863 = monoeg_strdup ("");
  return D.7863;
  <D.7862>:
  D.7864 = slen != 0;
  D.7865 = len != 0;
  D.7866 = D.7864 & D.7865;
  if (D.7866 != 0) goto <D.7867>; else goto <D.7868>;
  <D.7867>:
  len = len - slen;
  <D.7868>:
  D.7869 = len + 1;
  res = monoeg_malloc (D.7869);
  D.7870 = *str_array;
  r = monoeg_g_stpcpy (res, D.7870);
  i = 1;
  goto <D.7389>;
  <D.7388>:
  if (separator != 0B) goto <D.7871>; else goto <D.7872>;
  <D.7871>:
  r = monoeg_g_stpcpy (r, separator);
  <D.7872>:
  D.7857 = i * 4;
  D.7858 = str_array + D.7857;
  D.7859 = *D.7858;
  r = monoeg_g_stpcpy (r, D.7859);
  i = i + 1;
  <D.7389>:
  D.7857 = i * 4;
  D.7858 = str_array + D.7857;
  D.7859 = *D.7858;
  if (D.7859 != 0B) goto <D.7388>; else goto <D.7390>;
  <D.7390>:
  D.7863 = res;
  return D.7863;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.7876;
  char D.7877;
  const short unsigned int * * D.7879;
  const short unsigned int * D.7880;
  unsigned int D.7881;
  unsigned int D.7882;
  const short unsigned int * D.7883;
  short unsigned int D.7884;
  int D.7885;
  int D.7886;
  unsigned int D.7889;
  int str.17;
  int tmp.18;
  int D.7892;
  unsigned int D.7893;
  unsigned int D.7894;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.7874>; else goto <D.7875>;
  <D.7874>:
  D.7876 = 0B;
  return D.7876;
  <D.7875>:
  tmp = str;
  goto <D.7397>;
  <D.7396>:
  tmp = tmp + 1;
  <D.7397>:
  D.7877 = *tmp;
  if (D.7877 != 0) goto <D.7878>; else goto <D.7398>;
  <D.7878>:
  D.7879 = __ctype_b_loc ();
  D.7880 = *D.7879;
  D.7877 = *tmp;
  D.7881 = (unsigned int) D.7877;
  D.7882 = D.7881 * 2;
  D.7883 = D.7880 + D.7882;
  D.7884 = *D.7883;
  D.7885 = (int) D.7884;
  D.7886 = D.7885 & 8192;
  if (D.7886 != 0) goto <D.7396>; else goto <D.7398>;
  <D.7398>:
  if (str != tmp) goto <D.7887>; else goto <D.7888>;
  <D.7887>:
  D.7889 = strlen (str);
  str.17 = (int) str;
  tmp.18 = (int) tmp;
  D.7892 = str.17 - tmp.18;
  D.7893 = (unsigned int) D.7892;
  D.7894 = D.7889 + D.7893;
  len = D.7894 + 1;
  memmove (str, tmp, len);
  <D.7888>:
  D.7876 = str;
  return D.7876;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.7896;
  unsigned int D.7897;

  D.7897 = __builtin_object_size (__dest, 0);
  D.7896 = __builtin___memmove_chk (__dest, __src, __len, D.7897);
  return D.7896;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.7901;
  unsigned int D.7902;
  sizetype D.7903;
  char D.7904;
  const short unsigned int * * D.7906;
  const short unsigned int * D.7907;
  unsigned int D.7908;
  unsigned int D.7909;
  const short unsigned int * D.7910;
  short unsigned int D.7911;
  int D.7912;
  int D.7913;
  gchar * D.7914;
  gchar * tmp;

  if (str == 0B) goto <D.7899>; else goto <D.7900>;
  <D.7899>:
  D.7901 = 0B;
  return D.7901;
  <D.7900>:
  D.7902 = strlen (str);
  D.7903 = D.7902 + 4294967295;
  tmp = str + D.7903;
  goto <D.7404>;
  <D.7403>:
  tmp = tmp + 4294967295;
  <D.7404>:
  D.7904 = *tmp;
  if (D.7904 != 0) goto <D.7905>; else goto <D.7405>;
  <D.7905>:
  D.7906 = __ctype_b_loc ();
  D.7907 = *D.7906;
  D.7904 = *tmp;
  D.7908 = (unsigned int) D.7904;
  D.7909 = D.7908 * 2;
  D.7910 = D.7907 + D.7909;
  D.7911 = *D.7910;
  D.7912 = (int) D.7911;
  D.7913 = D.7912 & 8192;
  if (D.7913 != 0) goto <D.7403>; else goto <D.7405>;
  <D.7405>:
  D.7914 = tmp + 1;
  *D.7914 = 0;
  D.7901 = str;
  return D.7901;
}


monoeg_g_printf (const gchar * format)
{
  gint D.7916;
  struct va_list args;
  gint ret;

  try
    {
      __builtin_va_start (&args, 0);
      ret = vprintf (format, args);
      __builtin_va_end (&args);
      D.7916 = ret;
      return D.7916;
    }
  finally
    {
      args = {CLOBBER};
    }
}


vprintf (const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.7919;
  struct _IO_FILE * stdout.19;

  stdout.19 = stdout;
  D.7919 = __vfprintf_chk (stdout.19, 1, __fmt, __ap);
  return D.7919;
}


monoeg_g_fprintf (struct FILE * file, const gchar * format)
{
  gint D.7922;
  struct va_list args;
  gint ret;

  try
    {
      __builtin_va_start (&args, 0);
      ret = vfprintf (file, format, args);
      __builtin_va_end (&args);
      D.7922 = ret;
      return D.7922;
    }
  finally
    {
      args = {CLOBBER};
    }
}


vfprintf (struct FILE * restrict __stream, const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.7925;

  D.7925 = __vfprintf_chk (__stream, 1, __fmt, __ap);
  return D.7925;
}


monoeg_g_sprintf (gchar * string, const gchar * format)
{
  gint D.7927;
  struct va_list args;
  gint ret;

  try
    {
      __builtin_va_start (&args, 0);
      ret = vsprintf (string, format, args);
      __builtin_va_end (&args);
      D.7927 = ret;
      return D.7927;
    }
  finally
    {
      args = {CLOBBER};
    }
}


vsprintf (char * restrict __s, const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.7930;
  unsigned int D.7931;

  D.7931 = __builtin_object_size (__s, 1);
  D.7930 = __builtin___vsprintf_chk (__s, 1, D.7931, __fmt, __ap);
  return D.7930;
}


monoeg_g_snprintf (gchar * string, gulong n, const gchar * format)
{
  gint D.7933;
  struct va_list args;
  gint ret;

  try
    {
      __builtin_va_start (&args, 0);
      ret = vsnprintf (string, n, format, args);
      __builtin_va_end (&args);
      D.7933 = ret;
      return D.7933;
    }
  finally
    {
      args = {CLOBBER};
    }
}


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.7936;
  unsigned int D.7937;

  D.7937 = __builtin_object_size (__s, 1);
  D.7936 = __builtin___vsnprintf_chk (__s, __n, 1, D.7937, __fmt, __ap);
  return D.7936;
}


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.7941;
  int D.7944;
  struct GError * D.7949;
  unsigned int D.7950;
  char D.7951;
  int D.7952;
  unsigned int D.7956;
  int D.7957;
  char * rp.20;
  char * rp.21;
  unsigned char D.7962;
  int D.7963;
  char D.7964;
  char * rp.22;
  int D.7966;
  int D.7967;
  char D.7968;
  char * rp.23;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.7939>; else goto <D.7940>;
  <D.7939>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.7941 = 0B;
  return D.7941;
  <D.7940>:
  if (hostname != 0B) goto <D.7942>; else goto <D.7943>;
  <D.7942>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.7943>:
  D.7944 = monoeg_g_path_is_absolute (filename);
  if (D.7944 == 0) goto <D.7945>; else goto <D.7946>;
  <D.7945>:
  if (error != 0B) goto <D.7947>; else goto <D.7948>;
  <D.7947>:
  D.7949 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.7949;
  <D.7948>:
  D.7941 = 0B;
  return D.7941;
  <D.7946>:
  D.7950 = strlen (uriPrefix);
  n = D.7950 + 1;
  p = filename;
  goto <D.7445>;
  <D.7444>:
  D.7951 = *p;
  D.7952 = char_needs_encoding (D.7951);
  if (D.7952 != 0) goto <D.7953>; else goto <D.7954>;
  <D.7953>:
  n = n + 3;
  goto <D.7955>;
  <D.7954>:
  n = n + 1;
  <D.7955>:
  p = p + 1;
  <D.7445>:
  D.7951 = *p;
  if (D.7951 != 0) goto <D.7444>; else goto <D.7446>;
  <D.7446>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.7956 = strlen (ret);
  rp = ret + D.7956;
  goto <D.7448>;
  <D.7447>:
  D.7951 = *p;
  D.7957 = char_needs_encoding (D.7951);
  if (D.7957 != 0) goto <D.7958>; else goto <D.7959>;
  <D.7958>:
  rp.20 = rp;
  rp = rp.20 + 1;
  *rp.20 = 37;
  rp.21 = rp;
  rp = rp.21 + 1;
  D.7951 = *p;
  D.7962 = D.7951 >> 4;
  D.7963 = (int) D.7962;
  D.7964 = hx[D.7963];
  *rp.21 = D.7964;
  rp.22 = rp;
  rp = rp.22 + 1;
  D.7951 = *p;
  D.7966 = (int) D.7951;
  D.7967 = D.7966 & 15;
  D.7968 = hx[D.7967];
  *rp.22 = D.7968;
  goto <D.7969>;
  <D.7959>:
  rp.23 = rp;
  rp = rp.23 + 1;
  D.7951 = *p;
  *rp.23 = D.7951;
  <D.7969>:
  p = p + 1;
  <D.7448>:
  D.7951 = *p;
  if (D.7951 != 0) goto <D.7447>; else goto <D.7449>;
  <D.7449>:
  *rp = 0;
  D.7941 = ret;
  return D.7941;
}


char_needs_encoding (char c)
{
  signed char c.24;
  gboolean D.7975;
  char D.7978;
  _Bool D.7979;
  char D.7980;
  _Bool D.7981;
  _Bool D.7982;
  char D.7984;
  _Bool D.7986;
  _Bool D.7987;
  _Bool D.7988;
  _Bool D.7990;
  _Bool D.7991;
  _Bool D.7992;

  c.24 = (signed char) c;
  if (c.24 < 0) goto <D.7973>; else goto <D.7974>;
  <D.7973>:
  D.7975 = 1;
  return D.7975;
  <D.7974>:
  D.7978 = c + 192;
  D.7979 = D.7978 <= 26;
  D.7980 = c + 159;
  D.7981 = D.7980 <= 25;
  D.7982 = D.7979 | D.7981;
  if (D.7982 != 0) goto <D.7976>; else goto <D.7983>;
  <D.7983>:
  D.7984 = c + 218;
  if (D.7984 <= 20) goto <D.7976>; else goto <D.7985>;
  <D.7985>:
  D.7986 = c == 33;
  D.7987 = c == 36;
  D.7988 = D.7986 | D.7987;
  if (D.7988 != 0) goto <D.7976>; else goto <D.7989>;
  <D.7989>:
  D.7990 = c == 95;
  D.7991 = c == 61;
  D.7992 = D.7990 | D.7991;
  if (D.7992 != 0) goto <D.7976>; else goto <D.7993>;
  <D.7993>:
  if (c == 126) goto <D.7976>; else goto <D.7977>;
  <D.7976>:
  D.7975 = 0;
  return D.7975;
  <D.7977>:
  D.7975 = 1;
  return D.7975;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.7997;
  int D.8000;
  struct GError * D.8005;
  char D.8006;
  const char * D.8011;
  char D.8012;
  const char * D.8014;
  char D.8015;
  const short unsigned int * * D.8017;
  const short unsigned int * D.8018;
  unsigned int D.8019;
  unsigned int D.8020;
  const short unsigned int * D.8021;
  short unsigned int D.8022;
  int D.8023;
  int D.8024;
  unsigned int D.8026;
  unsigned int D.8027;
  const short unsigned int * D.8028;
  short unsigned int D.8029;
  int D.8030;
  int D.8031;
  struct GError * D.8035;
  int D.8036;
  unsigned int D.8037;
  sizetype flen.25;
  char * D.8039;
  char * r.26;
  int D.8043;
  int D.8044;
  signed char D.8045;
  int D.8046;
  signed char D.8047;
  signed char D.8048;
  char D.8049;
  char * r.27;
  const char * p;
  char * r;
  char * result;
  int flen;

  flen = 0;
  if (uri == 0B) goto <D.7995>; else goto <D.7996>;
  <D.7995>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 629, "uri != NULL");
  D.7997 = 0B;
  return D.7997;
  <D.7996>:
  if (hostname != 0B) goto <D.7998>; else goto <D.7999>;
  <D.7998>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_from_uri: hostname not handled");
  <D.7999>:
  D.8000 = strncmp (uri, "file:///", 8);
  if (D.8000 != 0) goto <D.8001>; else goto <D.8002>;
  <D.8001>:
  if (error != 0B) goto <D.8003>; else goto <D.8004>;
  <D.8003>:
  D.8005 = monoeg_g_error_new (0B, 2, "URI does not start with the file: scheme");
  *error = D.8005;
  <D.8004>:
  D.7997 = 0B;
  return D.7997;
  <D.8002>:
  p = uri + 8;
  goto <D.7472>;
  <D.7471>:
  D.8006 = *p;
  if (D.8006 == 37) goto <D.8007>; else goto <D.8008>;
  <D.8007>:
  D.8011 = p + 1;
  D.8012 = *D.8011;
  if (D.8012 != 0) goto <D.8013>; else goto <D.8009>;
  <D.8013>:
  D.8014 = p + 2;
  D.8015 = *D.8014;
  if (D.8015 != 0) goto <D.8016>; else goto <D.8009>;
  <D.8016>:
  D.8017 = __ctype_b_loc ();
  D.8018 = *D.8017;
  D.8011 = p + 1;
  D.8012 = *D.8011;
  D.8019 = (unsigned int) D.8012;
  D.8020 = D.8019 * 2;
  D.8021 = D.8018 + D.8020;
  D.8022 = *D.8021;
  D.8023 = (int) D.8022;
  D.8024 = D.8023 & 4096;
  if (D.8024 != 0) goto <D.8025>; else goto <D.8009>;
  <D.8025>:
  D.8017 = __ctype_b_loc ();
  D.8018 = *D.8017;
  D.8014 = p + 2;
  D.8015 = *D.8014;
  D.8026 = (unsigned int) D.8015;
  D.8027 = D.8026 * 2;
  D.8028 = D.8018 + D.8027;
  D.8029 = *D.8028;
  D.8030 = (int) D.8029;
  D.8031 = D.8030 & 4096;
  if (D.8031 != 0) goto <D.8032>; else goto <D.8009>;
  <D.8032>:
  p = p + 2;
  goto <D.8010>;
  <D.8009>:
  if (error != 0B) goto <D.8033>; else goto <D.8034>;
  <D.8033>:
  D.8035 = monoeg_g_error_new (0B, 2, "URI contains an invalid escape sequence");
  *error = D.8035;
  <D.8034>:
  D.7997 = 0B;
  return D.7997;
  <D.8010>:
  <D.8008>:
  flen = flen + 1;
  p = p + 1;
  <D.7472>:
  D.8006 = *p;
  if (D.8006 != 0) goto <D.7471>; else goto <D.7473>;
  <D.7473>:
  flen = flen + 1;
  D.8036 = flen + 1;
  D.8037 = (unsigned int) D.8036;
  result = monoeg_malloc (D.8037);
  flen.25 = (sizetype) flen;
  D.8039 = result + flen.25;
  *D.8039 = 0;
  *result = 47;
  r = result + 1;
  p = uri + 8;
  goto <D.7475>;
  <D.7474>:
  D.8006 = *p;
  if (D.8006 == 37) goto <D.8040>; else goto <D.8041>;
  <D.8040>:
  r.26 = r;
  r = r.26 + 1;
  D.8011 = p + 1;
  D.8012 = *D.8011;
  D.8043 = decode (D.8012);
  D.8044 = D.8043 << 4;
  D.8045 = (signed char) D.8044;
  D.8014 = p + 2;
  D.8015 = *D.8014;
  D.8046 = decode (D.8015);
  D.8047 = (signed char) D.8046;
  D.8048 = D.8045 | D.8047;
  D.8049 = (char) D.8048;
  *r.26 = D.8049;
  p = p + 2;
  goto <D.8050>;
  <D.8041>:
  r.27 = r;
  r = r.27 + 1;
  D.8006 = *p;
  *r.27 = D.8006;
  <D.8050>:
  flen = flen + 1;
  p = p + 1;
  <D.7475>:
  D.8006 = *p;
  if (D.8006 != 0) goto <D.7474>; else goto <D.7476>;
  <D.7476>:
  D.7997 = result;
  return D.7997;
}


decode (char p)
{
  char D.8053;
  int D.8056;
  int D.8057;
  char D.8058;
  char D.8061;

  D.8053 = p + 208;
  if (D.8053 <= 9) goto <D.8054>; else goto <D.8055>;
  <D.8054>:
  D.8057 = (int) p;
  D.8056 = D.8057 + -48;
  return D.8056;
  <D.8055>:
  D.8058 = p + 191;
  if (D.8058 <= 5) goto <D.8059>; else goto <D.8060>;
  <D.8059>:
  D.8057 = (int) p;
  D.8056 = D.8057 + -65;
  return D.8056;
  <D.8060>:
  D.8061 = p + 159;
  if (D.8061 <= 5) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  D.8057 = (int) p;
  D.8056 = D.8057 + -97;
  return D.8056;
  <D.8063>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gstr.c", 618);
  D.8056 = 0;
  return D.8056;
}


monoeg_g_strdown (gchar * string)
{
  int D.7482;
  char D.8069;
  int D.8070;
  int D.8071;
  const int iftmp.28;
  unsigned int __c.29;
  unsigned int D.8076;
  const __int32_t * * D.8079;
  const __int32_t * D.8080;
  unsigned int __c.30;
  unsigned int D.8082;
  const __int32_t * D.8083;
  unsigned int D.8087;
  unsigned int D.8088;
  const __int32_t * D.8089;
  char D.8090;

  if (string == 0B) goto <D.8065>; else goto <D.8066>;
  <D.8065>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 680, "string != NULL");
  return;
  <D.8066>:
  goto <D.7484>;
  <D.7483>:
  {
    int __res;

    {
      if (0 != 0) goto <D.8067>; else goto <D.8068>;
      <D.8067>:
      D.8069 = *string;
      D.8070 = (int) D.8069;
      D.8071 = __builtin_constant_p (D.8070);
      if (D.8071 != 0) goto <D.8072>; else goto <D.8073>;
      <D.8072>:
      {
        int __c;

        D.8069 = *string;
        __c = (int) D.8069;
        __c.29 = (unsigned int) __c;
        D.8076 = __c.29 + 128;
        if (D.8076 <= 383) goto <D.8077>; else goto <D.8078>;
        <D.8077>:
        D.8079 = __ctype_tolower_loc ();
        D.8080 = *D.8079;
        __c.30 = (unsigned int) __c;
        D.8082 = __c.30 * 4;
        D.8083 = D.8080 + D.8082;
        iftmp.28 = *D.8083;
        goto <D.8084>;
        <D.8078>:
        iftmp.28 = __c;
        <D.8084>:
        __res = iftmp.28;
      }
      goto <D.8085>;
      <D.8073>:
      D.8069 = *string;
      D.8070 = (int) D.8069;
      __res = tolower (D.8070);
      <D.8085>:
      goto <D.8086>;
      <D.8068>:
      D.8079 = __ctype_tolower_loc ();
      D.8080 = *D.8079;
      D.8069 = *string;
      D.8087 = (unsigned int) D.8069;
      D.8088 = D.8087 * 4;
      D.8089 = D.8080 + D.8088;
      __res = *D.8089;
      <D.8086>:
    }
    D.7482 = __res;
  }
  D.8090 = (char) D.7482;
  *string = D.8090;
  string = string + 1;
  <D.7484>:
  D.8069 = *string;
  if (D.8069 != 0) goto <D.7483>; else goto <D.7485>;
  <D.7485>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.8092;
  gchar iftmp.31;
  char D.8094;

  D.8094 = c + 191;
  if (D.8094 <= 25) goto <D.8095>; else goto <D.8096>;
  <D.8095>:
  iftmp.31 = c + 32;
  goto <D.8097>;
  <D.8096>:
  iftmp.31 = c;
  <D.8097>:
  D.8092 = iftmp.31;
  return D.8092;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.8101;
  unsigned int D.8104;
  int D.8105;
  unsigned int D.8106;
  sizetype i.32;
  char * D.8108;
  const gchar * D.8109;
  char D.8110;
  char D.8111;
  char * ret;
  int i;

  if (str == 0B) goto <D.8099>; else goto <D.8100>;
  <D.8099>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.8101 = 0B;
  return D.8101;
  <D.8100>:
  if (len == -1) goto <D.8102>; else goto <D.8103>;
  <D.8102>:
  D.8104 = strlen (str);
  len = (gssize) D.8104;
  <D.8103>:
  D.8105 = len + 1;
  D.8106 = (unsigned int) D.8105;
  ret = monoeg_malloc (D.8106);
  i = 0;
  goto <D.7496>;
  <D.7495>:
  i.32 = (sizetype) i;
  D.8108 = ret + i.32;
  i.32 = (sizetype) i;
  D.8109 = str + i.32;
  D.8110 = *D.8109;
  D.8111 = monoeg_g_ascii_tolower (D.8110);
  *D.8108 = D.8111;
  i = i + 1;
  <D.7496>:
  if (i < len) goto <D.7495>; else goto <D.7497>;
  <D.7497>:
  i.32 = (sizetype) i;
  D.8108 = ret + i.32;
  *D.8108 = 0;
  D.8101 = ret;
  return D.8101;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.8113;
  gchar iftmp.33;
  char D.8115;

  D.8115 = c + 159;
  if (D.8115 <= 25) goto <D.8116>; else goto <D.8117>;
  <D.8116>:
  iftmp.33 = c + 224;
  goto <D.8118>;
  <D.8117>:
  iftmp.33 = c;
  <D.8118>:
  D.8113 = iftmp.33;
  return D.8113;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.8122;
  unsigned int D.8125;
  int D.8126;
  unsigned int D.8127;
  sizetype i.34;
  char * D.8129;
  const gchar * D.8130;
  char D.8131;
  char D.8132;
  char * ret;
  int i;

  if (str == 0B) goto <D.8120>; else goto <D.8121>;
  <D.8120>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.8122 = 0B;
  return D.8122;
  <D.8121>:
  if (len == -1) goto <D.8123>; else goto <D.8124>;
  <D.8123>:
  D.8125 = strlen (str);
  len = (gssize) D.8125;
  <D.8124>:
  D.8126 = len + 1;
  D.8127 = (unsigned int) D.8126;
  ret = monoeg_malloc (D.8127);
  i = 0;
  goto <D.7508>;
  <D.7507>:
  i.34 = (sizetype) i;
  D.8129 = ret + i.34;
  i.34 = (sizetype) i;
  D.8130 = str + i.34;
  D.8131 = *D.8130;
  D.8132 = monoeg_ascii_toupper (D.8131);
  *D.8129 = D.8132;
  i = i + 1;
  <D.7508>:
  if (i < len) goto <D.7507>; else goto <D.7509>;
  <D.7509>:
  i.34 = (sizetype) i;
  D.8129 = ret + i.34;
  *D.8129 = 0;
  D.8122 = ret;
  return D.8122;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.8136;
  const gchar * s1.35;
  char D.8140;
  const gchar * s2.36;
  char D.8142;
  int D.8145;
  int D.8146;
  gsize i;

  if (s1 == 0B) goto <D.8134>; else goto <D.8135>;
  <D.8134>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.8136 = 0;
  return D.8136;
  <D.8135>:
  if (s2 == 0B) goto <D.8137>; else goto <D.8138>;
  <D.8137>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.8136 = 0;
  return D.8136;
  <D.8138>:
  i = 0;
  goto <D.7519>;
  <D.7518>:
  {
    gchar c1;
    gchar c2;

    s1.35 = s1;
    s1 = s1.35 + 1;
    D.8140 = *s1.35;
    c1 = monoeg_g_ascii_tolower (D.8140);
    s2.36 = s2;
    s2 = s2.36 + 1;
    D.8142 = *s2.36;
    c2 = monoeg_g_ascii_tolower (D.8142);
    if (c1 != c2) goto <D.8143>; else goto <D.8144>;
    <D.8143>:
    D.8145 = (int) c1;
    D.8146 = (int) c2;
    D.8136 = D.8145 - D.8146;
    return D.8136;
    <D.8144>:
  }
  i = i + 1;
  <D.7519>:
  if (i < n) goto <D.7518>; else goto <D.7520>;
  <D.7520>:
  D.8136 = 0;
  return D.8136;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.8150;
  const char * sp1.37;
  char D.8154;
  const char * sp2.38;
  char D.8156;
  int D.8159;
  int D.8160;
  char D.8161;
  int D.8162;
  char D.8163;
  int D.8164;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.8148>; else goto <D.8149>;
  <D.8148>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.8150 = 0;
  return D.8150;
  <D.8149>:
  if (s2 == 0B) goto <D.8151>; else goto <D.8152>;
  <D.8151>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.8150 = 0;
  return D.8150;
  <D.8152>:
  goto <D.7530>;
  <D.7529>:
  {
    char c1;
    char c2;

    sp1.37 = sp1;
    sp1 = sp1.37 + 1;
    D.8154 = *sp1.37;
    c1 = monoeg_g_ascii_tolower (D.8154);
    sp2.38 = sp2;
    sp2 = sp2.38 + 1;
    D.8156 = *sp2.38;
    c2 = monoeg_g_ascii_tolower (D.8156);
    if (c1 != c2) goto <D.8157>; else goto <D.8158>;
    <D.8157>:
    D.8159 = (int) c1;
    D.8160 = (int) c2;
    D.8150 = D.8159 - D.8160;
    return D.8150;
    <D.8158>:
  }
  <D.7530>:
  D.8161 = *sp1;
  if (D.8161 != 0) goto <D.7529>; else goto <D.7531>;
  <D.7531>:
  D.8161 = *sp1;
  D.8162 = (int) D.8161;
  D.8163 = *sp2;
  D.8164 = (int) D.8163;
  D.8150 = D.8162 - D.8164;
  return D.8150;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.8168;
  _Bool iftmp.39;
  char D.8174;
  int D.8175;
  int D.8176;
  void * D.8179;
  char * D.8180;
  gchar * ptr;

  if (string == 0B) goto <D.8166>; else goto <D.8167>;
  <D.8166>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.8168 = 0B;
  return D.8168;
  <D.8167>:
  if (delimiters == 0B) goto <D.8169>; else goto <D.8170>;
  <D.8169>:
  delimiters = "_-|> <.";
  <D.8170>:
  ptr = string;
  goto <D.7539>;
  <D.7538>:
  D.8174 = *ptr;
  D.8175 = (int) D.8174;
  D.8176 = __builtin_constant_p (D.8175);
  if (D.8176 != 0) goto <D.8177>; else goto <D.8172>;
  <D.8177>:
  D.8174 = *ptr;
  if (D.8174 == 0) goto <D.8178>; else goto <D.8172>;
  <D.8178>:
  D.8174 = *ptr;
  D.8175 = (int) D.8174;
  D.8179 = __rawmemchr (delimiters, D.8175);
  iftmp.39 = D.8179 != 0B;
  goto <D.8173>;
  <D.8172>:
  D.8174 = *ptr;
  D.8175 = (int) D.8174;
  D.8180 = __builtin_strchr (delimiters, D.8175);
  iftmp.39 = D.8180 != 0B;
  <D.8173>:
  if (iftmp.39 != 0) goto <D.8181>; else goto <D.8182>;
  <D.8181>:
  *ptr = new_delimiter;
  <D.8182>:
  ptr = ptr + 1;
  <D.7539>:
  D.8174 = *ptr;
  if (D.8174 != 0) goto <D.7538>; else goto <D.7540>;
  <D.7540>:
  D.8168 = string;
  return D.8168;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.8186;
  const gchar * s.40;
  gchar * d.41;
  unsigned int D.8195;
  const gchar * s.42;
  char D.8197;
  int s.43;
  int src.44;
  int D.8200;
  int D.8201;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.8184>; else goto <D.8185>;
  <D.8184>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.8186 = 0;
  return D.8186;
  <D.8185>:
  if (dest == 0B) goto <D.8187>; else goto <D.8188>;
  <D.8187>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.8186 = 0;
  return D.8186;
  <D.8188>:
  len = dest_size;
  if (len == 0) goto <D.8189>; else goto <D.8190>;
  <D.8189>:
  D.8186 = 0;
  return D.8186;
  <D.8190>:
  s = src;
  d = dest;
  goto <D.7551>;
  <D.7550>:
  s.40 = s;
  s = s.40 + 1;
  c = *s.40;
  d.41 = d;
  d = d.41 + 1;
  *d.41 = c;
  if (c == 0) goto <D.8193>; else goto <D.8194>;
  <D.8193>:
  D.8195 = dest_size - len;
  D.8186 = D.8195 + 4294967295;
  return D.8186;
  <D.8194>:
  <D.7551>:
  len = len + 4294967295;
  if (len != 0) goto <D.7550>; else goto <D.7552>;
  <D.7552>:
  *d = 0;
  goto <D.7554>;
  <D.7553>:
  <D.7554>:
  s.42 = s;
  s = s.42 + 1;
  D.8197 = *s.42;
  if (D.8197 != 0) goto <D.7553>; else goto <D.7555>;
  <D.7555>:
  s.43 = (int) s;
  src.44 = (int) src;
  D.8200 = s.43 - src.44;
  D.8201 = D.8200 + -1;
  D.8186 = (gsize) D.8201;
  return D.8186;
}


monoeg_g_stpcpy (gchar * dest, const char * src)
{
  gchar * D.8205;

  if (dest == 0B) goto <D.8203>; else goto <D.8204>;
  <D.8203>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.8205 = dest;
  return D.8205;
  <D.8204>:
  if (src == 0B) goto <D.8206>; else goto <D.8207>;
  <D.8206>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.8205 = dest;
  return D.8205;
  <D.8207>:
  D.8205 = stpcpy (dest, src);
  return D.8205;
}


stpcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.8209;
  unsigned int D.8210;

  D.8210 = __builtin_object_size (__dest, 1);
  D.8209 = __builtin___stpcpy_chk (__dest, __src, D.8210);
  return D.8209;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.8214;
  char D.8217;
  int D.8218;
  unsigned int D.8219;
  unsigned int D.8220;
  unsigned int D.8221;
  int D.8222;
  gchar * res_ptr.45;
  gchar * res_ptr.46;
  gchar * res_ptr.47;
  gchar * res_ptr.48;
  unsigned char D.8233;
  char D.8234;
  gchar * res_ptr.49;
  unsigned char D.8236;
  char D.8237;
  char D.8238;
  gchar * res_ptr.50;
  char D.8240;
  char D.8241;
  gchar escaped[256];
  const gchar * ptr;
  gchar c;
  gchar op;
  gchar * result;
  gchar * res_ptr;

  try
    {
      if (source == 0B) goto <D.8212>; else goto <D.8213>;
      <D.8212>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.8214 = 0B;
      return D.8214;
      <D.8213>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.8215>; else goto <D.8216>;
      <D.8215>:
      ptr = exceptions;
      goto <D.7572>;
      <D.7571>:
      D.8217 = *ptr;
      D.8218 = (int) D.8217;
      escaped[D.8218] = 0;
      ptr = ptr + 1;
      <D.7572>:
      D.8217 = *ptr;
      if (D.8217 != 0) goto <D.7571>; else goto <D.7573>;
      <D.7573>:
      <D.8216>:
      D.8219 = strlen (source);
      D.8220 = D.8219 * 4;
      D.8221 = D.8220 + 1;
      result = monoeg_malloc (D.8221);
      res_ptr = result;
      ptr = source;
      goto <D.7575>;
      <D.7574>:
      c = *ptr;
      D.8222 = (int) c;
      op = escaped[D.8222];
      if (op == 0) goto <D.8223>; else goto <D.8224>;
      <D.8223>:
      res_ptr.45 = res_ptr;
      res_ptr = res_ptr.45 + 1;
      *res_ptr.45 = c;
      goto <D.8226>;
      <D.8224>:
      res_ptr.46 = res_ptr;
      res_ptr = res_ptr.46 + 1;
      *res_ptr.46 = 92;
      if (op != 1) goto <D.8228>; else goto <D.8229>;
      <D.8228>:
      res_ptr.47 = res_ptr;
      res_ptr = res_ptr.47 + 1;
      *res_ptr.47 = op;
      goto <D.8231>;
      <D.8229>:
      res_ptr.48 = res_ptr;
      res_ptr = res_ptr.48 + 1;
      D.8233 = c >> 6;
      D.8234 = D.8233 + 48;
      *res_ptr.48 = D.8234;
      res_ptr.49 = res_ptr;
      res_ptr = res_ptr.49 + 1;
      D.8236 = c >> 3;
      D.8237 = D.8236 & 7;
      D.8238 = D.8237 + 48;
      *res_ptr.49 = D.8238;
      res_ptr.50 = res_ptr;
      res_ptr = res_ptr.50 + 1;
      D.8240 = c & 7;
      D.8241 = D.8240 + 48;
      *res_ptr.50 = D.8241;
      <D.8231>:
      <D.8226>:
      ptr = ptr + 1;
      <D.7575>:
      D.8217 = *ptr;
      if (D.8217 != 0) goto <D.7574>; else goto <D.7576>;
      <D.7576>:
      *res_ptr = 0;
      D.8214 = result;
      return D.8214;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.8244;
  unsigned int D.8245;

  D.8245 = __builtin_object_size (__dest, 0);
  D.8244 = __builtin___memcpy_chk (__dest, __src, __len, D.8245);
  return D.8244;
}


monoeg_g_ascii_xdigit_value (gchar c)
{
  gint D.8247;
  gint iftmp.51;
  const short unsigned int * * D.8249;
  const short unsigned int * D.8250;
  unsigned int D.8251;
  unsigned int D.8252;
  const short unsigned int * D.8253;
  short unsigned int D.8254;
  int D.8255;
  int D.8256;
  gint iftmp.52;
  char D.8260;
  int D.8263;
  gint iftmp.53;
  char D.8266;

  D.8249 = __ctype_b_loc ();
  D.8250 = *D.8249;
  D.8251 = (unsigned int) c;
  D.8252 = D.8251 * 2;
  D.8253 = D.8250 + D.8252;
  D.8254 = *D.8253;
  D.8255 = (int) D.8254;
  D.8256 = D.8255 & 4096;
  if (D.8256 != 0) goto <D.8257>; else goto <D.8258>;
  <D.8257>:
  D.8260 = c + 208;
  if (D.8260 <= 9) goto <D.8261>; else goto <D.8262>;
  <D.8261>:
  D.8263 = (int) c;
  iftmp.52 = D.8263 + -48;
  goto <D.8264>;
  <D.8262>:
  D.8266 = c + 159;
  if (D.8266 <= 5) goto <D.8267>; else goto <D.8268>;
  <D.8267>:
  D.8263 = (int) c;
  iftmp.53 = D.8263 + -87;
  goto <D.8269>;
  <D.8268>:
  D.8263 = (int) c;
  iftmp.53 = D.8263 + -55;
  <D.8269>:
  iftmp.52 = iftmp.53;
  <D.8264>:
  iftmp.51 = iftmp.52;
  goto <D.8270>;
  <D.8258>:
  iftmp.51 = -1;
  <D.8270>:
  D.8247 = iftmp.51;
  return D.8247;
}


monoeg_g_strnfill (gsize length, gchar fill_char)
{
  unsigned int D.8272;
  int D.8273;
  gchar * D.8274;
  gchar * D.8275;
  gchar * ret;

  D.8272 = length + 1;
  ret = monoeg_malloc (D.8272);
  D.8273 = (int) fill_char;
  memset (ret, D.8273, length);
  D.8274 = ret + length;
  *D.8274 = 0;
  D.8275 = ret;
  return D.8275;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.8279;
  int D.8284;
  void * D.8286;
  unsigned int D.8287;

  D.8279 = __builtin_constant_p (__len);
  if (D.8279 != 0) goto <D.8280>; else goto <D.8281>;
  <D.8280>:
  if (__len == 0) goto <D.8282>; else goto <D.8283>;
  <D.8282>:
  D.8284 = __builtin_constant_p (__ch);
  if (D.8284 == 0) goto <D.8277>; else goto <D.8285>;
  <D.8285>:
  if (__ch != 0) goto <D.8277>; else goto <D.8278>;
  <D.8277>:
  __warn_memset_zero_len ();
  D.8286 = __dest;
  return D.8286;
  <D.8278>:
  <D.8283>:
  <D.8281>:
  D.8287 = __builtin_object_size (__dest, 0);
  D.8286 = __builtin___memset_chk (__dest, __ch, __len, D.8287);
  return D.8286;
}