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

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


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

  orig = str_array;
  if (str_array == 0B) goto <D.5845>; else goto <D.5846>;
  <D.5845>:
  return;
  <D.5846>:
  goto <D.5447>;
  <D.5446>:
  D.5847 = *str_array;
  monoeg_g_free (D.5847);
  str_array = str_array + 8;
  <D.5447>:
  D.5847 = *str_array;
  if (D.5847 != 0B) goto <D.5446>; else goto <D.5448>;
  <D.5448>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.5851;
  unsigned int D.5852;
  long unsigned int D.5853;
  long unsigned int D.5854;
  long unsigned int D.5855;
  long unsigned int D.5856;
  gchar * * D.5857;
  gchar * * D.5858;
  gchar * D.5859;
  gchar * D.5860;
  long unsigned int D.5861;
  long unsigned int D.5862;
  gchar * * D.5863;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.5849>; else goto <D.5850>;
  <D.5849>:
  D.5851 = 0B;
  return D.5851;
  <D.5850>:
  length = monoeg_g_strv_length (str_array);
  D.5852 = length + 1;
  D.5853 = (long unsigned int) D.5852;
  D.5854 = D.5853 * 8;
  ret = monoeg_malloc0 (D.5854);
  i = 0;
  goto <D.5456>;
  <D.5455>:
  D.5855 = (long unsigned int) i;
  D.5856 = D.5855 * 8;
  D.5857 = ret + D.5856;
  D.5855 = (long unsigned int) i;
  D.5856 = D.5855 * 8;
  D.5858 = str_array + D.5856;
  D.5859 = *D.5858;
  D.5860 = monoeg_strdup (D.5859);
  *D.5857 = D.5860;
  i = i + 1;
  <D.5456>:
  D.5855 = (long unsigned int) i;
  D.5856 = D.5855 * 8;
  D.5858 = str_array + D.5856;
  D.5859 = *D.5858;
  if (D.5859 != 0B) goto <D.5455>; else goto <D.5457>;
  <D.5457>:
  D.5861 = (long unsigned int) length;
  D.5862 = D.5861 * 8;
  D.5863 = ret + D.5862;
  *D.5863 = 0B;
  D.5851 = ret;
  return D.5851;
}


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

  if (str != 0B) goto <D.5865>; else goto <D.5866>;
  <D.5865>:
  D.5867 = __strdup (str);
  return D.5867;
  <D.5866>:
  D.5867 = 0B;
  return D.5867;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.5871;
  long unsigned int D.5872;
  long unsigned int D.5873;
  gchar * * D.5874;
  gchar * D.5875;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.5869>; else goto <D.5870>;
  <D.5869>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.5871 = 0;
  return D.5871;
  <D.5870>:
  length = 0;
  goto <D.5463>;
  <D.5462>:
  length = length + 1;
  <D.5463>:
  D.5872 = (long unsigned int) length;
  D.5873 = D.5872 * 8;
  D.5874 = str_array + D.5873;
  D.5875 = *D.5874;
  if (D.5875 != 0B) goto <D.5462>; else goto <D.5464>;
  <D.5464>:
  D.5871 = (guint) length;
  return D.5871;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.5879;
  int iftmp.0;
  sizetype D.5886;
  const gchar * D.5887;
  int D.5888;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.5877>; else goto <D.5878>;
  <D.5877>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.5879 = 0;
  return D.5879;
  <D.5878>:
  if (suffix == 0B) goto <D.5880>; else goto <D.5881>;
  <D.5880>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.5879 = 0;
  return D.5879;
  <D.5881>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.5885>; else goto <D.5883>;
  <D.5885>:
  D.5886 = str_length - suffix_length;
  D.5887 = str + D.5886;
  D.5888 = strncmp (D.5887, suffix, suffix_length);
  if (D.5888 == 0) goto <D.5889>; else goto <D.5883>;
  <D.5889>:
  iftmp.0 = 1;
  goto <D.5884>;
  <D.5883>:
  iftmp.0 = 0;
  <D.5884>:
  D.5879 = iftmp.0;
  return D.5879;
}


monoeg_g_str_has_prefix (const gchar * str, const gchar * prefix)
{
  gboolean D.5893;
  int iftmp.1;
  int D.5900;
  size_t str_length;
  size_t prefix_length;

  if (str == 0B) goto <D.5891>; else goto <D.5892>;
  <D.5891>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.5893 = 0;
  return D.5893;
  <D.5892>:
  if (prefix == 0B) goto <D.5894>; else goto <D.5895>;
  <D.5894>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.5893 = 0;
  return D.5893;
  <D.5895>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.5899>; else goto <D.5897>;
  <D.5899>:
  D.5900 = strncmp (str, prefix, prefix_length);
  if (D.5900 == 0) goto <D.5901>; else goto <D.5897>;
  <D.5901>:
  iftmp.1 = 1;
  goto <D.5898>;
  <D.5897>:
  iftmp.1 = 0;
  <D.5898>:
  D.5893 = iftmp.1;
  return D.5893;
}


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

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


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

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


monoeg_g_strdup_printf (const gchar * format)
{
  char * args.2;
  gchar * D.5913;
  gchar * ret;
  char * args;
  int n;

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


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

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


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.5920;
  long unsigned int D.5921;
  char * args.3;
  char * args.4;
  long unsigned int D.5924;
  char * args.5;
  char * args.6;
  long unsigned int D.5927;
  char * D.5930;
  char * args.7;
  char * args.8;
  char * args.9;
  char * args.10;
  char * args;
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.5918>; else goto <D.5919>;
      <D.5918>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.5920 = 0B;
      return D.5920;
      <D.5919>:
      D.5921 = strlen (first);
      total = D.5921 + total;
      __builtin_va_start (&args, 0);
      args.3 = args;
      args.4 = args.3 + 8;
      args = args.4;
      s = MEM[(char * *)args.3];
      goto <D.5518>;
      <D.5517>:
      D.5924 = strlen (s);
      total = D.5924 + total;
      args.5 = args;
      args.6 = args.5 + 8;
      args = args.6;
      s = MEM[(char * *)args.5];
      <D.5518>:
      if (s != 0B) goto <D.5517>; else goto <D.5519>;
      <D.5519>:
      __builtin_va_end (&args);
      D.5927 = total + 1;
      ret = monoeg_malloc (D.5927);
      if (ret == 0B) goto <D.5928>; else goto <D.5929>;
      <D.5928>:
      D.5920 = 0B;
      return D.5920;
      <D.5929>:
      D.5930 = ret + total;
      *D.5930 = 0;
      strcpy (ret, first);
      __builtin_va_start (&args, 0);
      args.7 = args;
      args.8 = args.7 + 8;
      args = args.8;
      s = MEM[(char * *)args.7];
      goto <D.5521>;
      <D.5520>:
      strcat (ret, s);
      args.9 = args;
      args.10 = args.9 + 8;
      args = args.10;
      s = MEM[(char * *)args.9];
      <D.5521>:
      if (s != 0B) goto <D.5520>; else goto <D.5522>;
      <D.5522>:
      __builtin_va_end (&args);
      D.5920 = ret;
      return D.5920;
    }
  finally
    {
      args = {CLOBBER};
    }
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.5937;
  long unsigned int D.5938;

  D.5938 = __builtin_object_size (__dest, 1);
  D.5937 = __builtin___strcpy_chk (__dest, __src, D.5938);
  return D.5937;
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.5940;
  long unsigned int D.5941;

  D.5941 = __builtin_object_size (__dest, 1);
  D.5940 = __builtin___strcat_chk (__dest, __src, D.5941);
  return D.5940;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5945;
  char D.5948;
  long unsigned int D.5951;
  int D.5952;
  void * vector.11;
  gchar * * vector.12;
  gchar * D.5957;
  long unsigned int D.5958;
  long unsigned int D.5960;
  int D.5961;
  long unsigned int D.5964;
  char D.5966;
  long unsigned int D.5968;
  int D.5969;
  long int string.13;
  long int c.14;
  long int D.5974;
  int D.5576;
  long unsigned int D.5977;
  int D.5588;
  gchar * D.5985;
  gchar * D.5987;
  void * vector.15;
  long unsigned int D.5994;
  long unsigned int D.5995;
  sizetype D.5996;
  gchar * * D.5997;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5943>; else goto <D.5944>;
      <D.5943>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.5945 = 0B;
      return D.5945;
      <D.5944>:
      if (delimiter == 0B) goto <D.5946>; else goto <D.5947>;
      <D.5946>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.5945 = 0B;
      return D.5945;
      <D.5947>:
      D.5948 = *delimiter;
      if (D.5948 == 0) goto <D.5949>; else goto <D.5950>;
      <D.5949>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.5945 = 0B;
      return D.5945;
      <D.5950>:
      D.5951 = strlen (delimiter);
      D.5952 = strncmp (string, delimiter, D.5951);
      if (D.5952 == 0) goto <D.5953>; else goto <D.5954>;
      <D.5953>:
      vector.11 = monoeg_malloc (16);
      vector = vector.11;
      vector.12 = vector;
      D.5957 = monoeg_strdup ("");
      *vector.12 = D.5957;
      size = size + 1;
      D.5958 = strlen (delimiter);
      string = string + D.5958;
      goto <D.5959>;
      <D.5954>:
      vector = 0B;
      <D.5959>:
      goto <D.5578>;
      <D.5577>:
      c = string;
      D.5960 = strlen (delimiter);
      D.5961 = strncmp (string, delimiter, D.5960);
      if (D.5961 == 0) goto <D.5962>; else goto <D.5963>;
      <D.5962>:
      token = monoeg_strdup ("");
      D.5964 = strlen (delimiter);
      string = string + D.5964;
      goto <D.5965>;
      <D.5963>:
      goto <D.5565>;
      <D.5564>:
      string = string + 1;
      <D.5565>:
      D.5966 = *string;
      if (D.5966 != 0) goto <D.5967>; else goto <D.5566>;
      <D.5967>:
      D.5968 = strlen (delimiter);
      D.5969 = strncmp (string, delimiter, D.5968);
      if (D.5969 != 0) goto <D.5564>; else goto <D.5566>;
      <D.5566>:
      D.5966 = *string;
      if (D.5966 != 0) goto <D.5970>; else goto <D.5971>;
      <D.5970>:
      {
        gsize toklen;

        string.13 = (long int) string;
        c.14 = (long int) c;
        D.5974 = string.13 - c.14;
        toklen = (gsize) D.5974;
        token = monoeg_g_strndup (c, toklen);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.5576 = __builtin_strcmp (string, delimiter);
        }
        if (D.5576 != 0) goto <D.5975>; else goto <D.5976>;
        <D.5975>:
        D.5977 = strlen (delimiter);
        string = string + D.5977;
        <D.5976>:
      }
      goto <D.5978>;
      <D.5971>:
      token = monoeg_strdup (c);
      <D.5978>:
      <D.5965>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.5578>:
      D.5966 = *string;
      if (D.5966 != 0) goto <D.5979>; else goto <D.5579>;
      <D.5979>:
      if (max_tokens <= 0) goto <D.5577>; else goto <D.5980>;
      <D.5980>:
      if (size < max_tokens) goto <D.5577>; else goto <D.5579>;
      <D.5579>:
      D.5966 = *string;
      if (D.5966 != 0) goto <D.5981>; else goto <D.5982>;
      <D.5981>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.5588 = __builtin_strcmp (string, delimiter);
      }
      if (D.5588 == 0) goto <D.5983>; else goto <D.5984>;
      <D.5983>:
      D.5985 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5985);
      goto <D.5986>;
      <D.5984>:
      D.5987 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5987);
      <D.5986>:
      size = size + 1;
      <D.5982>:
      vector.12 = vector;
      if (vector.12 == 0B) goto <D.5988>; else goto <D.5989>;
      <D.5988>:
      vector.15 = monoeg_malloc (16);
      vector = vector.15;
      vector.12 = vector;
      *vector.12 = 0B;
      goto <D.5991>;
      <D.5989>:
      if (size > 0) goto <D.5992>; else goto <D.5993>;
      <D.5992>:
      vector.12 = vector;
      D.5994 = (long unsigned int) size;
      D.5995 = D.5994 * 8;
      D.5996 = D.5995 + 18446744073709551608;
      D.5997 = vector.12 + D.5996;
      *D.5997 = 0B;
      <D.5993>:
      <D.5991>:
      D.5945 = vector;
      return D.5945;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.16;
  gchar * * D.6001;
  int D.6005;
  long unsigned int D.6006;
  long unsigned int D.6007;
  long unsigned int D.6008;
  long unsigned int D.6009;
  sizetype D.6010;
  gchar * * D.6011;

  D.6001 = *vector;
  if (D.6001 == 0B) goto <D.6002>; else goto <D.6003>;
  <D.6002>:
  iftmp.16 = monoeg_malloc (16);
  goto <D.6004>;
  <D.6003>:
  D.6001 = *vector;
  D.6005 = size + 1;
  D.6006 = (long unsigned int) D.6005;
  D.6007 = D.6006 * 8;
  iftmp.16 = monoeg_realloc (D.6001, D.6007);
  <D.6004>:
  *vector = iftmp.16;
  D.6001 = *vector;
  D.6008 = (long unsigned int) size;
  D.6009 = D.6008 * 8;
  D.6010 = D.6009 + 18446744073709551608;
  D.6011 = D.6001 + D.6010;
  *D.6011 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.6014;
  char D.6017;
  char D.6020;
  int D.6021;
  void * vector.17;
  gchar * * vector.18;
  gchar * D.6026;
  int D.6028;
  long int string.19;
  long int c.20;
  long int D.6033;
  gchar * D.6045;
  char D.6046;
  gchar * D.6049;
  gchar * D.6051;
  void * vector.21;
  long unsigned int D.6058;
  long unsigned int D.6059;
  sizetype D.6060;
  gchar * * D.6061;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.6012>; else goto <D.6013>;
      <D.6012>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.6014 = 0B;
      return D.6014;
      <D.6013>:
      if (delimiter == 0B) goto <D.6015>; else goto <D.6016>;
      <D.6015>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.6014 = 0B;
      return D.6014;
      <D.6016>:
      D.6017 = *delimiter;
      if (D.6017 == 0) goto <D.6018>; else goto <D.6019>;
      <D.6018>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.6014 = 0B;
      return D.6014;
      <D.6019>:
      D.6020 = *string;
      D.6021 = charcmp (D.6020, delimiter);
      if (D.6021 != 0) goto <D.6022>; else goto <D.6023>;
      <D.6022>:
      vector.17 = monoeg_malloc (16);
      vector = vector.17;
      vector.18 = vector;
      D.6026 = monoeg_strdup ("");
      *vector.18 = D.6026;
      size = size + 1;
      string = string + 1;
      goto <D.6027>;
      <D.6023>:
      vector = 0B;
      <D.6027>:
      c = string;
      goto <D.5607>;
      <D.5606>:
      D.6020 = *string;
      D.6028 = charcmp (D.6020, delimiter);
      if (D.6028 != 0) goto <D.6029>; else goto <D.6030>;
      <D.6029>:
      {
        gsize toklen;

        string.19 = (long int) string;
        c.20 = (long int) c;
        D.6033 = string.19 - c.20;
        toklen = (gsize) D.6033;
        if (toklen == 0) goto <D.6034>; else goto <D.6035>;
        <D.6034>:
        token = monoeg_strdup ("");
        goto <D.6036>;
        <D.6035>:
        token = monoeg_g_strndup (c, toklen);
        <D.6036>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.6030>:
      string = string + 1;
      <D.5607>:
      D.6020 = *string;
      if (D.6020 != 0) goto <D.6037>; else goto <D.5608>;
      <D.6037>:
      if (max_tokens <= 0) goto <D.5606>; else goto <D.6038>;
      <D.6038>:
      if (size < max_tokens) goto <D.5606>; else goto <D.5608>;
      <D.5608>:
      if (max_tokens > 0) goto <D.6041>; else goto <D.6039>;
      <D.6041>:
      if (size >= max_tokens) goto <D.6042>; else goto <D.6039>;
      <D.6042>:
      D.6020 = *string;
      if (D.6020 != 0) goto <D.6043>; else goto <D.6044>;
      <D.6043>:
      D.6045 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.6045);
      size = size + 1;
      <D.6044>:
      goto <D.6040>;
      <D.6039>:
      D.6046 = *c;
      if (D.6046 != 0) goto <D.6047>; else goto <D.6048>;
      <D.6047>:
      D.6049 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.6049);
      size = size + 1;
      goto <D.6050>;
      <D.6048>:
      D.6051 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.6051);
      size = size + 1;
      <D.6050>:
      <D.6040>:
      vector.18 = vector;
      if (vector.18 == 0B) goto <D.6052>; else goto <D.6053>;
      <D.6052>:
      vector.21 = monoeg_malloc (16);
      vector = vector.21;
      vector.18 = vector;
      *vector.18 = 0B;
      goto <D.6055>;
      <D.6053>:
      if (size > 0) goto <D.6056>; else goto <D.6057>;
      <D.6056>:
      vector.18 = vector;
      D.6058 = (long unsigned int) size;
      D.6059 = D.6058 * 8;
      D.6060 = D.6059 + 18446744073709551608;
      D.6061 = vector.18 + D.6060;
      *D.6061 = 0B;
      <D.6057>:
      <D.6055>:
      D.6014 = vector;
      return D.6014;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.6064;
  gboolean D.6067;

  goto <D.5594>;
  <D.5593>:
  D.6064 = *compare;
  if (D.6064 == testchar) goto <D.6065>; else goto <D.6066>;
  <D.6065>:
  D.6067 = 1;
  return D.6067;
  <D.6066>:
  compare = compare + 1;
  <D.5594>:
  D.6064 = *compare;
  if (D.6064 != 0) goto <D.5593>; else goto <D.5595>;
  <D.5595>:
  D.6067 = 0;
  return D.6067;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.6071;
  char D.6072;
  long unsigned int D.6075;
  gchar * D.6076;
  gchar * D.6077;
  char D.6078;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.6069>; else goto <D.6070>;
  <D.6069>:
  D.6071 = 0B;
  return D.6071;
  <D.6070>:
  D.6072 = *str;
  if (D.6072 == 0) goto <D.6073>; else goto <D.6074>;
  <D.6073>:
  D.6071 = str;
  return D.6071;
  <D.6074>:
  i = 0;
  D.6075 = strlen (str);
  j = D.6075 + 18446744073709551615;
  goto <D.5616>;
  <D.5615>:
  D.6076 = str + i;
  c = *D.6076;
  D.6076 = str + i;
  D.6077 = str + j;
  D.6078 = *D.6077;
  *D.6076 = D.6078;
  D.6077 = str + j;
  *D.6077 = c;
  i = i + 1;
  j = j + 18446744073709551615;
  <D.5616>:
  if (i < j) goto <D.5615>; else goto <D.5617>;
  <D.5617>:
  D.6071 = str;
  return D.6071;
}


monoeg_g_strjoin (const gchar * separator)
{
  char * args.22;
  char * args.23;
  long unsigned int D.6085;
  char * args.24;
  char * args.25;
  gchar * D.6090;
  long unsigned int D.6095;
  char * args.26;
  char * args.27;
  char * args.28;
  char * args.29;
  char * args.30;
  char * args.31;
  char * args;
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.6080>; else goto <D.6081>;
      <D.6080>:
      slen = strlen (separator);
      goto <D.6082>;
      <D.6081>:
      slen = 0;
      <D.6082>:
      len = 0;
      __builtin_va_start (&args, 0);
      args.22 = args;
      args.23 = args.22 + 8;
      args = args.23;
      s = MEM[(char * *)args.22];
      goto <D.5628>;
      <D.5627>:
      D.6085 = strlen (s);
      len = D.6085 + len;
      len = len + slen;
      args.24 = args;
      args.25 = args.24 + 8;
      args = args.25;
      s = MEM[(char * *)args.24];
      <D.5628>:
      if (s != 0B) goto <D.5627>; else goto <D.5629>;
      <D.5629>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.6088>; else goto <D.6089>;
      <D.6088>:
      D.6090 = monoeg_strdup ("");
      return D.6090;
      <D.6089>:
      if (slen != 0) goto <D.6091>; else goto <D.6092>;
      <D.6091>:
      if (len != 0) goto <D.6093>; else goto <D.6094>;
      <D.6093>:
      len = len - slen;
      <D.6094>:
      <D.6092>:
      D.6095 = len + 1;
      res = monoeg_malloc (D.6095);
      __builtin_va_start (&args, 0);
      args.26 = args;
      args.27 = args.26 + 8;
      args = args.27;
      s = MEM[(char * *)args.26];
      r = monoeg_g_stpcpy (res, s);
      args.28 = args;
      args.29 = args.28 + 8;
      args = args.29;
      s = MEM[(char * *)args.28];
      goto <D.5631>;
      <D.5630>:
      if (separator != 0B) goto <D.6100>; else goto <D.6101>;
      <D.6100>:
      r = monoeg_g_stpcpy (r, separator);
      <D.6101>:
      r = monoeg_g_stpcpy (r, s);
      args.30 = args;
      args.31 = args.30 + 8;
      args = args.31;
      s = MEM[(char * *)args.30];
      <D.5631>:
      if (s != 0B) goto <D.5630>; else goto <D.5632>;
      <D.5632>:
      __builtin_va_end (&args);
      D.6090 = res;
      return D.6090;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  long unsigned int D.6109;
  gchar * * D.6110;
  gchar * D.6111;
  long unsigned int D.6112;
  gchar * D.6115;
  long unsigned int D.6120;
  gchar * D.6121;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.6106>; else goto <D.6107>;
  <D.6106>:
  slen = strlen (separator);
  goto <D.6108>;
  <D.6107>:
  slen = 0;
  <D.6108>:
  len = 0;
  i = 0;
  goto <D.5643>;
  <D.5642>:
  D.6109 = i * 8;
  D.6110 = str_array + D.6109;
  D.6111 = *D.6110;
  D.6112 = strlen (D.6111);
  len = D.6112 + len;
  len = len + slen;
  i = i + 1;
  <D.5643>:
  D.6109 = i * 8;
  D.6110 = str_array + D.6109;
  D.6111 = *D.6110;
  if (D.6111 != 0B) goto <D.5642>; else goto <D.5644>;
  <D.5644>:
  if (len == 0) goto <D.6113>; else goto <D.6114>;
  <D.6113>:
  D.6115 = monoeg_strdup ("");
  return D.6115;
  <D.6114>:
  if (slen != 0) goto <D.6116>; else goto <D.6117>;
  <D.6116>:
  if (len != 0) goto <D.6118>; else goto <D.6119>;
  <D.6118>:
  len = len - slen;
  <D.6119>:
  <D.6117>:
  D.6120 = len + 1;
  res = monoeg_malloc (D.6120);
  D.6121 = *str_array;
  r = monoeg_g_stpcpy (res, D.6121);
  i = 1;
  goto <D.5646>;
  <D.5645>:
  if (separator != 0B) goto <D.6122>; else goto <D.6123>;
  <D.6122>:
  r = monoeg_g_stpcpy (r, separator);
  <D.6123>:
  D.6109 = i * 8;
  D.6110 = str_array + D.6109;
  D.6111 = *D.6110;
  r = monoeg_g_stpcpy (r, D.6111);
  i = i + 1;
  <D.5646>:
  D.6109 = i * 8;
  D.6110 = str_array + D.6109;
  D.6111 = *D.6110;
  if (D.6111 != 0B) goto <D.5645>; else goto <D.5647>;
  <D.5647>:
  D.6115 = res;
  return D.6115;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.6127;
  char D.6128;
  const short unsigned int * * D.6130;
  const short unsigned int * D.6131;
  long unsigned int D.6132;
  long unsigned int D.6133;
  const short unsigned int * D.6134;
  short unsigned int D.6135;
  int D.6136;
  int D.6137;
  long unsigned int D.6140;
  long int str.32;
  long int tmp.33;
  long int D.6143;
  long unsigned int D.6144;
  long unsigned int D.6145;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.6125>; else goto <D.6126>;
  <D.6125>:
  D.6127 = 0B;
  return D.6127;
  <D.6126>:
  tmp = str;
  goto <D.5654>;
  <D.5653>:
  tmp = tmp + 1;
  <D.5654>:
  D.6128 = *tmp;
  if (D.6128 != 0) goto <D.6129>; else goto <D.5655>;
  <D.6129>:
  D.6130 = __ctype_b_loc ();
  D.6131 = *D.6130;
  D.6128 = *tmp;
  D.6132 = (long unsigned int) D.6128;
  D.6133 = D.6132 * 2;
  D.6134 = D.6131 + D.6133;
  D.6135 = *D.6134;
  D.6136 = (int) D.6135;
  D.6137 = D.6136 & 8192;
  if (D.6137 != 0) goto <D.5653>; else goto <D.5655>;
  <D.5655>:
  if (str != tmp) goto <D.6138>; else goto <D.6139>;
  <D.6138>:
  D.6140 = strlen (str);
  str.32 = (long int) str;
  tmp.33 = (long int) tmp;
  D.6143 = str.32 - tmp.33;
  D.6144 = (long unsigned int) D.6143;
  D.6145 = D.6140 + D.6144;
  len = D.6145 + 1;
  memmove (str, tmp, len);
  <D.6139>:
  D.6127 = str;
  return D.6127;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.6147;
  long unsigned int D.6148;

  D.6148 = __builtin_object_size (__dest, 0);
  D.6147 = __builtin___memmove_chk (__dest, __src, __len, D.6148);
  return D.6147;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.6152;
  long unsigned int D.6153;
  sizetype D.6154;
  char D.6155;
  const short unsigned int * * D.6157;
  const short unsigned int * D.6158;
  long unsigned int D.6159;
  long unsigned int D.6160;
  const short unsigned int * D.6161;
  short unsigned int D.6162;
  int D.6163;
  int D.6164;
  gchar * D.6165;
  gchar * tmp;

  if (str == 0B) goto <D.6150>; else goto <D.6151>;
  <D.6150>:
  D.6152 = 0B;
  return D.6152;
  <D.6151>:
  D.6153 = strlen (str);
  D.6154 = D.6153 + 18446744073709551615;
  tmp = str + D.6154;
  goto <D.5661>;
  <D.5660>:
  tmp = tmp + 18446744073709551615;
  <D.5661>:
  D.6155 = *tmp;
  if (D.6155 != 0) goto <D.6156>; else goto <D.5662>;
  <D.6156>:
  D.6157 = __ctype_b_loc ();
  D.6158 = *D.6157;
  D.6155 = *tmp;
  D.6159 = (long unsigned int) D.6155;
  D.6160 = D.6159 * 2;
  D.6161 = D.6158 + D.6160;
  D.6162 = *D.6161;
  D.6163 = (int) D.6162;
  D.6164 = D.6163 & 8192;
  if (D.6164 != 0) goto <D.5660>; else goto <D.5662>;
  <D.5662>:
  D.6165 = tmp + 1;
  *D.6165 = 0;
  D.6152 = str;
  return D.6152;
}


monoeg_g_printf (const gchar * format)
{
  char * args.34;
  gint D.6168;
  char * args;
  gint ret;

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


vprintf (const char * restrict __fmt, char * __ap)
{
  int D.6171;
  struct _IO_FILE * stdout.35;

  stdout.35 = stdout;
  D.6171 = __vfprintf_chk (stdout.35, 1, __fmt, __ap);
  return D.6171;
}


monoeg_g_fprintf (struct FILE * file, const gchar * format)
{
  char * args.36;
  gint D.6175;
  char * args;
  gint ret;

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


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

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


monoeg_g_sprintf (gchar * string, const gchar * format)
{
  char * args.37;
  gint D.6181;
  char * args;
  gint ret;

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


vsprintf (char * restrict __s, const char * restrict __fmt, char * __ap)
{
  int D.6184;
  long unsigned int D.6185;

  D.6185 = __builtin_object_size (__s, 1);
  D.6184 = __builtin___vsprintf_chk (__s, 1, D.6185, __fmt, __ap);
  return D.6184;
}


monoeg_g_snprintf (gchar * string, gulong n, const gchar * format)
{
  char * args.38;
  gint D.6188;
  char * args;
  gint ret;

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


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, char * __ap)
{
  int D.6191;
  long unsigned int D.6192;

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


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.6196;
  int D.6199;
  struct GError * D.6204;
  long unsigned int D.6205;
  char D.6206;
  int D.6207;
  long unsigned int D.6211;
  int D.6212;
  char * rp.39;
  char * rp.40;
  unsigned char D.6217;
  int D.6218;
  char D.6219;
  char * rp.41;
  int D.6221;
  int D.6222;
  char D.6223;
  char * rp.42;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.6194>; else goto <D.6195>;
  <D.6194>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.6196 = 0B;
  return D.6196;
  <D.6195>:
  if (hostname != 0B) goto <D.6197>; else goto <D.6198>;
  <D.6197>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.6198>:
  D.6199 = monoeg_g_path_is_absolute (filename);
  if (D.6199 == 0) goto <D.6200>; else goto <D.6201>;
  <D.6200>:
  if (error != 0B) goto <D.6202>; else goto <D.6203>;
  <D.6202>:
  D.6204 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.6204;
  <D.6203>:
  D.6196 = 0B;
  return D.6196;
  <D.6201>:
  D.6205 = strlen (uriPrefix);
  n = D.6205 + 1;
  p = filename;
  goto <D.5702>;
  <D.5701>:
  D.6206 = *p;
  D.6207 = char_needs_encoding (D.6206);
  if (D.6207 != 0) goto <D.6208>; else goto <D.6209>;
  <D.6208>:
  n = n + 3;
  goto <D.6210>;
  <D.6209>:
  n = n + 1;
  <D.6210>:
  p = p + 1;
  <D.5702>:
  D.6206 = *p;
  if (D.6206 != 0) goto <D.5701>; else goto <D.5703>;
  <D.5703>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.6211 = strlen (ret);
  rp = ret + D.6211;
  goto <D.5705>;
  <D.5704>:
  D.6206 = *p;
  D.6212 = char_needs_encoding (D.6206);
  if (D.6212 != 0) goto <D.6213>; else goto <D.6214>;
  <D.6213>:
  rp.39 = rp;
  rp = rp.39 + 1;
  *rp.39 = 37;
  rp.40 = rp;
  rp = rp.40 + 1;
  D.6206 = *p;
  D.6217 = D.6206 >> 4;
  D.6218 = (int) D.6217;
  D.6219 = hx[D.6218];
  *rp.40 = D.6219;
  rp.41 = rp;
  rp = rp.41 + 1;
  D.6206 = *p;
  D.6221 = (int) D.6206;
  D.6222 = D.6221 & 15;
  D.6223 = hx[D.6222];
  *rp.41 = D.6223;
  goto <D.6224>;
  <D.6214>:
  rp.42 = rp;
  rp = rp.42 + 1;
  D.6206 = *p;
  *rp.42 = D.6206;
  <D.6224>:
  p = p + 1;
  <D.5705>:
  D.6206 = *p;
  if (D.6206 != 0) goto <D.5704>; else goto <D.5706>;
  <D.5706>:
  *rp = 0;
  D.6196 = ret;
  return D.6196;
}


char_needs_encoding (char c)
{
  signed char c.43;
  gboolean D.6230;
  char D.6233;
  char D.6235;
  char D.6237;

  c.43 = (signed char) c;
  if (c.43 < 0) goto <D.6228>; else goto <D.6229>;
  <D.6228>:
  D.6230 = 1;
  return D.6230;
  <D.6229>:
  D.6233 = c + 192;
  if (D.6233 <= 26) goto <D.6231>; else goto <D.6234>;
  <D.6234>:
  D.6235 = c + 159;
  if (D.6235 <= 25) goto <D.6231>; else goto <D.6236>;
  <D.6236>:
  D.6237 = c + 218;
  if (D.6237 <= 20) goto <D.6231>; else goto <D.6238>;
  <D.6238>:
  if (c == 33) goto <D.6231>; else goto <D.6239>;
  <D.6239>:
  if (c == 36) goto <D.6231>; else goto <D.6240>;
  <D.6240>:
  if (c == 95) goto <D.6231>; else goto <D.6241>;
  <D.6241>:
  if (c == 61) goto <D.6231>; else goto <D.6242>;
  <D.6242>:
  if (c == 126) goto <D.6231>; else goto <D.6232>;
  <D.6231>:
  D.6230 = 0;
  return D.6230;
  <D.6232>:
  D.6230 = 1;
  return D.6230;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.6246;
  int D.6249;
  struct GError * D.6254;
  char D.6255;
  const char * D.6260;
  char D.6261;
  const char * D.6263;
  char D.6264;
  const short unsigned int * * D.6266;
  const short unsigned int * D.6267;
  long unsigned int D.6268;
  long unsigned int D.6269;
  const short unsigned int * D.6270;
  short unsigned int D.6271;
  int D.6272;
  int D.6273;
  long unsigned int D.6275;
  long unsigned int D.6276;
  const short unsigned int * D.6277;
  short unsigned int D.6278;
  int D.6279;
  int D.6280;
  struct GError * D.6284;
  int D.6285;
  long unsigned int D.6286;
  sizetype D.6287;
  char * D.6288;
  char * r.44;
  int D.6292;
  int D.6293;
  signed char D.6294;
  int D.6295;
  signed char D.6296;
  signed char D.6297;
  char D.6298;
  char * r.45;
  const char * p;
  char * r;
  char * result;
  int flen;

  flen = 0;
  if (uri == 0B) goto <D.6244>; else goto <D.6245>;
  <D.6244>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 629, "uri != NULL");
  D.6246 = 0B;
  return D.6246;
  <D.6245>:
  if (hostname != 0B) goto <D.6247>; else goto <D.6248>;
  <D.6247>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_from_uri: hostname not handled");
  <D.6248>:
  D.6249 = strncmp (uri, "file:///", 8);
  if (D.6249 != 0) goto <D.6250>; else goto <D.6251>;
  <D.6250>:
  if (error != 0B) goto <D.6252>; else goto <D.6253>;
  <D.6252>:
  D.6254 = monoeg_g_error_new (0B, 2, "URI does not start with the file: scheme");
  *error = D.6254;
  <D.6253>:
  D.6246 = 0B;
  return D.6246;
  <D.6251>:
  p = uri + 8;
  goto <D.5729>;
  <D.5728>:
  D.6255 = *p;
  if (D.6255 == 37) goto <D.6256>; else goto <D.6257>;
  <D.6256>:
  D.6260 = p + 1;
  D.6261 = *D.6260;
  if (D.6261 != 0) goto <D.6262>; else goto <D.6258>;
  <D.6262>:
  D.6263 = p + 2;
  D.6264 = *D.6263;
  if (D.6264 != 0) goto <D.6265>; else goto <D.6258>;
  <D.6265>:
  D.6266 = __ctype_b_loc ();
  D.6267 = *D.6266;
  D.6260 = p + 1;
  D.6261 = *D.6260;
  D.6268 = (long unsigned int) D.6261;
  D.6269 = D.6268 * 2;
  D.6270 = D.6267 + D.6269;
  D.6271 = *D.6270;
  D.6272 = (int) D.6271;
  D.6273 = D.6272 & 4096;
  if (D.6273 != 0) goto <D.6274>; else goto <D.6258>;
  <D.6274>:
  D.6266 = __ctype_b_loc ();
  D.6267 = *D.6266;
  D.6263 = p + 2;
  D.6264 = *D.6263;
  D.6275 = (long unsigned int) D.6264;
  D.6276 = D.6275 * 2;
  D.6277 = D.6267 + D.6276;
  D.6278 = *D.6277;
  D.6279 = (int) D.6278;
  D.6280 = D.6279 & 4096;
  if (D.6280 != 0) goto <D.6281>; else goto <D.6258>;
  <D.6281>:
  p = p + 2;
  goto <D.6259>;
  <D.6258>:
  if (error != 0B) goto <D.6282>; else goto <D.6283>;
  <D.6282>:
  D.6284 = monoeg_g_error_new (0B, 2, "URI contains an invalid escape sequence");
  *error = D.6284;
  <D.6283>:
  D.6246 = 0B;
  return D.6246;
  <D.6259>:
  <D.6257>:
  flen = flen + 1;
  p = p + 1;
  <D.5729>:
  D.6255 = *p;
  if (D.6255 != 0) goto <D.5728>; else goto <D.5730>;
  <D.5730>:
  flen = flen + 1;
  D.6285 = flen + 1;
  D.6286 = (long unsigned int) D.6285;
  result = monoeg_malloc (D.6286);
  D.6287 = (sizetype) flen;
  D.6288 = result + D.6287;
  *D.6288 = 0;
  *result = 47;
  r = result + 1;
  p = uri + 8;
  goto <D.5732>;
  <D.5731>:
  D.6255 = *p;
  if (D.6255 == 37) goto <D.6289>; else goto <D.6290>;
  <D.6289>:
  r.44 = r;
  r = r.44 + 1;
  D.6260 = p + 1;
  D.6261 = *D.6260;
  D.6292 = decode (D.6261);
  D.6293 = D.6292 << 4;
  D.6294 = (signed char) D.6293;
  D.6263 = p + 2;
  D.6264 = *D.6263;
  D.6295 = decode (D.6264);
  D.6296 = (signed char) D.6295;
  D.6297 = D.6294 | D.6296;
  D.6298 = (char) D.6297;
  *r.44 = D.6298;
  p = p + 2;
  goto <D.6299>;
  <D.6290>:
  r.45 = r;
  r = r.45 + 1;
  D.6255 = *p;
  *r.45 = D.6255;
  <D.6299>:
  flen = flen + 1;
  p = p + 1;
  <D.5732>:
  D.6255 = *p;
  if (D.6255 != 0) goto <D.5731>; else goto <D.5733>;
  <D.5733>:
  D.6246 = result;
  return D.6246;
}


decode (char p)
{
  char D.6302;
  int D.6305;
  int D.6306;
  char D.6307;
  char D.6310;

  D.6302 = p + 208;
  if (D.6302 <= 9) goto <D.6303>; else goto <D.6304>;
  <D.6303>:
  D.6306 = (int) p;
  D.6305 = D.6306 + -48;
  return D.6305;
  <D.6304>:
  D.6307 = p + 191;
  if (D.6307 <= 5) goto <D.6308>; else goto <D.6309>;
  <D.6308>:
  D.6306 = (int) p;
  D.6305 = D.6306 + -65;
  return D.6305;
  <D.6309>:
  D.6310 = p + 159;
  if (D.6310 <= 5) goto <D.6311>; else goto <D.6312>;
  <D.6311>:
  D.6306 = (int) p;
  D.6305 = D.6306 + -97;
  return D.6305;
  <D.6312>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gstr.c", 618);
  D.6305 = 0;
  return D.6305;
}


monoeg_g_strdown (gchar * string)
{
  int D.5739;
  char D.6318;
  int D.6319;
  int D.6320;
  const int iftmp.46;
  unsigned int __c.47;
  unsigned int D.6325;
  const __int32_t * * D.6328;
  const __int32_t * D.6329;
  long unsigned int D.6330;
  long unsigned int D.6331;
  const __int32_t * D.6332;
  long unsigned int D.6336;
  long unsigned int D.6337;
  const __int32_t * D.6338;
  char D.6339;

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

    {
      if (0 != 0) goto <D.6316>; else goto <D.6317>;
      <D.6316>:
      D.6318 = *string;
      D.6319 = (int) D.6318;
      D.6320 = __builtin_constant_p (D.6319);
      if (D.6320 != 0) goto <D.6321>; else goto <D.6322>;
      <D.6321>:
      {
        int __c;

        D.6318 = *string;
        __c = (int) D.6318;
        __c.47 = (unsigned int) __c;
        D.6325 = __c.47 + 128;
        if (D.6325 <= 383) goto <D.6326>; else goto <D.6327>;
        <D.6326>:
        D.6328 = __ctype_tolower_loc ();
        D.6329 = *D.6328;
        D.6330 = (long unsigned int) __c;
        D.6331 = D.6330 * 4;
        D.6332 = D.6329 + D.6331;
        iftmp.46 = *D.6332;
        goto <D.6333>;
        <D.6327>:
        iftmp.46 = __c;
        <D.6333>:
        __res = iftmp.46;
      }
      goto <D.6334>;
      <D.6322>:
      D.6318 = *string;
      D.6319 = (int) D.6318;
      __res = tolower (D.6319);
      <D.6334>:
      goto <D.6335>;
      <D.6317>:
      D.6328 = __ctype_tolower_loc ();
      D.6329 = *D.6328;
      D.6318 = *string;
      D.6336 = (long unsigned int) D.6318;
      D.6337 = D.6336 * 4;
      D.6338 = D.6329 + D.6337;
      __res = *D.6338;
      <D.6335>:
    }
    D.5739 = __res;
  }
  D.6339 = (char) D.5739;
  *string = D.6339;
  string = string + 1;
  <D.5741>:
  D.6318 = *string;
  if (D.6318 != 0) goto <D.5740>; else goto <D.5742>;
  <D.5742>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.6341;
  gchar iftmp.48;
  char D.6343;

  D.6343 = c + 191;
  if (D.6343 <= 25) goto <D.6344>; else goto <D.6345>;
  <D.6344>:
  iftmp.48 = c + 32;
  goto <D.6346>;
  <D.6345>:
  iftmp.48 = c;
  <D.6346>:
  D.6341 = iftmp.48;
  return D.6341;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.6350;
  long unsigned int D.6353;
  long int D.6354;
  long unsigned int D.6355;
  sizetype D.6356;
  char * D.6357;
  const gchar * D.6358;
  char D.6359;
  char D.6360;
  long int D.6361;
  char * ret;
  int i;

  if (str == 0B) goto <D.6348>; else goto <D.6349>;
  <D.6348>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.6350 = 0B;
  return D.6350;
  <D.6349>:
  if (len == -1) goto <D.6351>; else goto <D.6352>;
  <D.6351>:
  D.6353 = strlen (str);
  len = (gssize) D.6353;
  <D.6352>:
  D.6354 = len + 1;
  D.6355 = (long unsigned int) D.6354;
  ret = monoeg_malloc (D.6355);
  i = 0;
  goto <D.5753>;
  <D.5752>:
  D.6356 = (sizetype) i;
  D.6357 = ret + D.6356;
  D.6356 = (sizetype) i;
  D.6358 = str + D.6356;
  D.6359 = *D.6358;
  D.6360 = monoeg_g_ascii_tolower (D.6359);
  *D.6357 = D.6360;
  i = i + 1;
  <D.5753>:
  D.6361 = (long int) i;
  if (D.6361 < len) goto <D.5752>; else goto <D.5754>;
  <D.5754>:
  D.6356 = (sizetype) i;
  D.6357 = ret + D.6356;
  *D.6357 = 0;
  D.6350 = ret;
  return D.6350;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.6363;
  gchar iftmp.49;
  char D.6365;

  D.6365 = c + 159;
  if (D.6365 <= 25) goto <D.6366>; else goto <D.6367>;
  <D.6366>:
  iftmp.49 = c + 224;
  goto <D.6368>;
  <D.6367>:
  iftmp.49 = c;
  <D.6368>:
  D.6363 = iftmp.49;
  return D.6363;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.6372;
  long unsigned int D.6375;
  long int D.6376;
  long unsigned int D.6377;
  sizetype D.6378;
  char * D.6379;
  const gchar * D.6380;
  char D.6381;
  char D.6382;
  long int D.6383;
  char * ret;
  int i;

  if (str == 0B) goto <D.6370>; else goto <D.6371>;
  <D.6370>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.6372 = 0B;
  return D.6372;
  <D.6371>:
  if (len == -1) goto <D.6373>; else goto <D.6374>;
  <D.6373>:
  D.6375 = strlen (str);
  len = (gssize) D.6375;
  <D.6374>:
  D.6376 = len + 1;
  D.6377 = (long unsigned int) D.6376;
  ret = monoeg_malloc (D.6377);
  i = 0;
  goto <D.5765>;
  <D.5764>:
  D.6378 = (sizetype) i;
  D.6379 = ret + D.6378;
  D.6378 = (sizetype) i;
  D.6380 = str + D.6378;
  D.6381 = *D.6380;
  D.6382 = monoeg_ascii_toupper (D.6381);
  *D.6379 = D.6382;
  i = i + 1;
  <D.5765>:
  D.6383 = (long int) i;
  if (D.6383 < len) goto <D.5764>; else goto <D.5766>;
  <D.5766>:
  D.6378 = (sizetype) i;
  D.6379 = ret + D.6378;
  *D.6379 = 0;
  D.6372 = ret;
  return D.6372;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.6387;
  const gchar * s1.50;
  char D.6391;
  const gchar * s2.51;
  char D.6393;
  int D.6396;
  int D.6397;
  gsize i;

  if (s1 == 0B) goto <D.6385>; else goto <D.6386>;
  <D.6385>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.6387 = 0;
  return D.6387;
  <D.6386>:
  if (s2 == 0B) goto <D.6388>; else goto <D.6389>;
  <D.6388>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.6387 = 0;
  return D.6387;
  <D.6389>:
  i = 0;
  goto <D.5776>;
  <D.5775>:
  {
    gchar c1;
    gchar c2;

    s1.50 = s1;
    s1 = s1.50 + 1;
    D.6391 = *s1.50;
    c1 = monoeg_g_ascii_tolower (D.6391);
    s2.51 = s2;
    s2 = s2.51 + 1;
    D.6393 = *s2.51;
    c2 = monoeg_g_ascii_tolower (D.6393);
    if (c1 != c2) goto <D.6394>; else goto <D.6395>;
    <D.6394>:
    D.6396 = (int) c1;
    D.6397 = (int) c2;
    D.6387 = D.6396 - D.6397;
    return D.6387;
    <D.6395>:
  }
  i = i + 1;
  <D.5776>:
  if (i < n) goto <D.5775>; else goto <D.5777>;
  <D.5777>:
  D.6387 = 0;
  return D.6387;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.6401;
  const char * sp1.52;
  char D.6405;
  const char * sp2.53;
  char D.6407;
  int D.6410;
  int D.6411;
  char D.6412;
  int D.6413;
  char D.6414;
  int D.6415;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.6399>; else goto <D.6400>;
  <D.6399>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.6401 = 0;
  return D.6401;
  <D.6400>:
  if (s2 == 0B) goto <D.6402>; else goto <D.6403>;
  <D.6402>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.6401 = 0;
  return D.6401;
  <D.6403>:
  goto <D.5787>;
  <D.5786>:
  {
    char c1;
    char c2;

    sp1.52 = sp1;
    sp1 = sp1.52 + 1;
    D.6405 = *sp1.52;
    c1 = monoeg_g_ascii_tolower (D.6405);
    sp2.53 = sp2;
    sp2 = sp2.53 + 1;
    D.6407 = *sp2.53;
    c2 = monoeg_g_ascii_tolower (D.6407);
    if (c1 != c2) goto <D.6408>; else goto <D.6409>;
    <D.6408>:
    D.6410 = (int) c1;
    D.6411 = (int) c2;
    D.6401 = D.6410 - D.6411;
    return D.6401;
    <D.6409>:
  }
  <D.5787>:
  D.6412 = *sp1;
  if (D.6412 != 0) goto <D.5786>; else goto <D.5788>;
  <D.5788>:
  D.6412 = *sp1;
  D.6413 = (int) D.6412;
  D.6414 = *sp2;
  D.6415 = (int) D.6414;
  D.6401 = D.6413 - D.6415;
  return D.6401;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.6419;
  _Bool iftmp.54;
  char D.6425;
  int D.6426;
  int D.6427;
  void * D.6430;
  char * D.6431;
  gchar * ptr;

  if (string == 0B) goto <D.6417>; else goto <D.6418>;
  <D.6417>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.6419 = 0B;
  return D.6419;
  <D.6418>:
  if (delimiters == 0B) goto <D.6420>; else goto <D.6421>;
  <D.6420>:
  delimiters = "_-|> <.";
  <D.6421>:
  ptr = string;
  goto <D.5796>;
  <D.5795>:
  D.6425 = *ptr;
  D.6426 = (int) D.6425;
  D.6427 = __builtin_constant_p (D.6426);
  if (D.6427 != 0) goto <D.6428>; else goto <D.6423>;
  <D.6428>:
  D.6425 = *ptr;
  if (D.6425 == 0) goto <D.6429>; else goto <D.6423>;
  <D.6429>:
  D.6425 = *ptr;
  D.6426 = (int) D.6425;
  D.6430 = __rawmemchr (delimiters, D.6426);
  iftmp.54 = D.6430 != 0B;
  goto <D.6424>;
  <D.6423>:
  D.6425 = *ptr;
  D.6426 = (int) D.6425;
  D.6431 = __builtin_strchr (delimiters, D.6426);
  iftmp.54 = D.6431 != 0B;
  <D.6424>:
  if (iftmp.54 != 0) goto <D.6432>; else goto <D.6433>;
  <D.6432>:
  *ptr = new_delimiter;
  <D.6433>:
  ptr = ptr + 1;
  <D.5796>:
  D.6425 = *ptr;
  if (D.6425 != 0) goto <D.5795>; else goto <D.5797>;
  <D.5797>:
  D.6419 = string;
  return D.6419;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.6437;
  const gchar * s.55;
  gchar * d.56;
  long unsigned int D.6446;
  const gchar * s.57;
  char D.6448;
  long int s.58;
  long int src.59;
  long int D.6451;
  long int D.6452;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.6435>; else goto <D.6436>;
  <D.6435>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.6437 = 0;
  return D.6437;
  <D.6436>:
  if (dest == 0B) goto <D.6438>; else goto <D.6439>;
  <D.6438>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.6437 = 0;
  return D.6437;
  <D.6439>:
  len = dest_size;
  if (len == 0) goto <D.6440>; else goto <D.6441>;
  <D.6440>:
  D.6437 = 0;
  return D.6437;
  <D.6441>:
  s = src;
  d = dest;
  goto <D.5808>;
  <D.5807>:
  s.55 = s;
  s = s.55 + 1;
  c = *s.55;
  d.56 = d;
  d = d.56 + 1;
  *d.56 = c;
  if (c == 0) goto <D.6444>; else goto <D.6445>;
  <D.6444>:
  D.6446 = dest_size - len;
  D.6437 = D.6446 + 18446744073709551615;
  return D.6437;
  <D.6445>:
  <D.5808>:
  len = len + 18446744073709551615;
  if (len != 0) goto <D.5807>; else goto <D.5809>;
  <D.5809>:
  *d = 0;
  goto <D.5811>;
  <D.5810>:
  <D.5811>:
  s.57 = s;
  s = s.57 + 1;
  D.6448 = *s.57;
  if (D.6448 != 0) goto <D.5810>; else goto <D.5812>;
  <D.5812>:
  s.58 = (long int) s;
  src.59 = (long int) src;
  D.6451 = s.58 - src.59;
  D.6452 = D.6451 + -1;
  D.6437 = (gsize) D.6452;
  return D.6437;
}


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

  if (dest == 0B) goto <D.6454>; else goto <D.6455>;
  <D.6454>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.6456 = dest;
  return D.6456;
  <D.6455>:
  if (src == 0B) goto <D.6457>; else goto <D.6458>;
  <D.6457>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.6456 = dest;
  return D.6456;
  <D.6458>:
  D.6456 = stpcpy (dest, src);
  return D.6456;
}


stpcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.6460;
  long unsigned int D.6461;

  D.6461 = __builtin_object_size (__dest, 1);
  D.6460 = __builtin___stpcpy_chk (__dest, __src, D.6461);
  return D.6460;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.6465;
  char D.6468;
  int D.6469;
  long unsigned int D.6470;
  long unsigned int D.6471;
  long unsigned int D.6472;
  int D.6473;
  gchar * res_ptr.60;
  gchar * res_ptr.61;
  gchar * res_ptr.62;
  gchar * res_ptr.63;
  unsigned char D.6484;
  char D.6485;
  gchar * res_ptr.64;
  unsigned char D.6487;
  char D.6488;
  char D.6489;
  gchar * res_ptr.65;
  char D.6491;
  char D.6492;
  gchar escaped[256];
  const gchar * ptr;
  gchar c;
  gchar op;
  gchar * result;
  gchar * res_ptr;

  try
    {
      if (source == 0B) goto <D.6463>; else goto <D.6464>;
      <D.6463>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.6465 = 0B;
      return D.6465;
      <D.6464>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.6466>; else goto <D.6467>;
      <D.6466>:
      ptr = exceptions;
      goto <D.5829>;
      <D.5828>:
      D.6468 = *ptr;
      D.6469 = (int) D.6468;
      escaped[D.6469] = 0;
      ptr = ptr + 1;
      <D.5829>:
      D.6468 = *ptr;
      if (D.6468 != 0) goto <D.5828>; else goto <D.5830>;
      <D.5830>:
      <D.6467>:
      D.6470 = strlen (source);
      D.6471 = D.6470 * 4;
      D.6472 = D.6471 + 1;
      result = monoeg_malloc (D.6472);
      res_ptr = result;
      ptr = source;
      goto <D.5832>;
      <D.5831>:
      c = *ptr;
      D.6473 = (int) c;
      op = escaped[D.6473];
      if (op == 0) goto <D.6474>; else goto <D.6475>;
      <D.6474>:
      res_ptr.60 = res_ptr;
      res_ptr = res_ptr.60 + 1;
      *res_ptr.60 = c;
      goto <D.6477>;
      <D.6475>:
      res_ptr.61 = res_ptr;
      res_ptr = res_ptr.61 + 1;
      *res_ptr.61 = 92;
      if (op != 1) goto <D.6479>; else goto <D.6480>;
      <D.6479>:
      res_ptr.62 = res_ptr;
      res_ptr = res_ptr.62 + 1;
      *res_ptr.62 = op;
      goto <D.6482>;
      <D.6480>:
      res_ptr.63 = res_ptr;
      res_ptr = res_ptr.63 + 1;
      D.6484 = c >> 6;
      D.6485 = D.6484 + 48;
      *res_ptr.63 = D.6485;
      res_ptr.64 = res_ptr;
      res_ptr = res_ptr.64 + 1;
      D.6487 = c >> 3;
      D.6488 = D.6487 & 7;
      D.6489 = D.6488 + 48;
      *res_ptr.64 = D.6489;
      res_ptr.65 = res_ptr;
      res_ptr = res_ptr.65 + 1;
      D.6491 = c & 7;
      D.6492 = D.6491 + 48;
      *res_ptr.65 = D.6492;
      <D.6482>:
      <D.6477>:
      ptr = ptr + 1;
      <D.5832>:
      D.6468 = *ptr;
      if (D.6468 != 0) goto <D.5831>; else goto <D.5833>;
      <D.5833>:
      *res_ptr = 0;
      D.6465 = result;
      return D.6465;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.6495;
  long unsigned int D.6496;

  D.6496 = __builtin_object_size (__dest, 0);
  D.6495 = __builtin___memcpy_chk (__dest, __src, __len, D.6496);
  return D.6495;
}


monoeg_g_ascii_xdigit_value (gchar c)
{
  gint D.6498;
  gint iftmp.66;
  const short unsigned int * * D.6500;
  const short unsigned int * D.6501;
  long unsigned int D.6502;
  long unsigned int D.6503;
  const short unsigned int * D.6504;
  short unsigned int D.6505;
  int D.6506;
  int D.6507;
  gint iftmp.67;
  char D.6511;
  int D.6514;
  gint iftmp.68;
  char D.6517;

  D.6500 = __ctype_b_loc ();
  D.6501 = *D.6500;
  D.6502 = (long unsigned int) c;
  D.6503 = D.6502 * 2;
  D.6504 = D.6501 + D.6503;
  D.6505 = *D.6504;
  D.6506 = (int) D.6505;
  D.6507 = D.6506 & 4096;
  if (D.6507 != 0) goto <D.6508>; else goto <D.6509>;
  <D.6508>:
  D.6511 = c + 208;
  if (D.6511 <= 9) goto <D.6512>; else goto <D.6513>;
  <D.6512>:
  D.6514 = (int) c;
  iftmp.67 = D.6514 + -48;
  goto <D.6515>;
  <D.6513>:
  D.6517 = c + 159;
  if (D.6517 <= 5) goto <D.6518>; else goto <D.6519>;
  <D.6518>:
  D.6514 = (int) c;
  iftmp.68 = D.6514 + -87;
  goto <D.6520>;
  <D.6519>:
  D.6514 = (int) c;
  iftmp.68 = D.6514 + -55;
  <D.6520>:
  iftmp.67 = iftmp.68;
  <D.6515>:
  iftmp.66 = iftmp.67;
  goto <D.6521>;
  <D.6509>:
  iftmp.66 = -1;
  <D.6521>:
  D.6498 = iftmp.66;
  return D.6498;
}


monoeg_g_strnfill (gsize length, gchar fill_char)
{
  long unsigned int D.6523;
  int D.6524;
  gchar * D.6525;
  gchar * D.6526;
  gchar * ret;

  D.6523 = length + 1;
  ret = monoeg_malloc (D.6523);
  D.6524 = (int) fill_char;
  memset (ret, D.6524, length);
  D.6525 = ret + length;
  *D.6525 = 0;
  D.6526 = ret;
  return D.6526;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.6530;
  int D.6535;
  void * D.6537;
  long unsigned int D.6538;

  D.6530 = __builtin_constant_p (__len);
  if (D.6530 != 0) goto <D.6531>; else goto <D.6532>;
  <D.6531>:
  if (__len == 0) goto <D.6533>; else goto <D.6534>;
  <D.6533>:
  D.6535 = __builtin_constant_p (__ch);
  if (D.6535 == 0) goto <D.6528>; else goto <D.6536>;
  <D.6536>:
  if (__ch != 0) goto <D.6528>; else goto <D.6529>;
  <D.6528>:
  __warn_memset_zero_len ();
  D.6537 = __dest;
  return D.6537;
  <D.6529>:
  <D.6534>:
  <D.6532>:
  D.6538 = __builtin_object_size (__dest, 0);
  D.6537 = __builtin___memset_chk (__dest, __ch, __len, D.6538);
  return D.6537;
}