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

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


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

  orig = str_array;
  if (str_array == 0B) goto <D.4981>; else goto <D.4982>;
  <D.4981>:
  return;
  <D.4982>:
  goto <D.4583>;
  <D.4582>:
  D.4983 = *str_array;
  monoeg_g_free (D.4983);
  str_array = str_array + 4;
  <D.4583>:
  D.4983 = *str_array;
  if (D.4983 != 0B) goto <D.4582>; else goto <D.4584>;
  <D.4584>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.4987;
  unsigned int D.4988;
  unsigned int D.4989;
  unsigned int D.4990;
  gchar * * D.4991;
  gchar * * D.4992;
  gchar * D.4993;
  gchar * D.4994;
  unsigned int D.4995;
  gchar * * D.4996;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.4985>; else goto <D.4986>;
  <D.4985>:
  D.4987 = 0B;
  return D.4987;
  <D.4986>:
  length = monoeg_g_strv_length (str_array);
  D.4988 = length + 1;
  D.4989 = D.4988 * 4;
  ret = monoeg_malloc0 (D.4989);
  i = 0;
  goto <D.4592>;
  <D.4591>:
  D.4990 = i * 4;
  D.4991 = ret + D.4990;
  D.4990 = i * 4;
  D.4992 = str_array + D.4990;
  D.4993 = *D.4992;
  D.4994 = monoeg_strdup (D.4993);
  *D.4991 = D.4994;
  i = i + 1;
  <D.4592>:
  D.4990 = i * 4;
  D.4992 = str_array + D.4990;
  D.4993 = *D.4992;
  if (D.4993 != 0B) goto <D.4591>; else goto <D.4593>;
  <D.4593>:
  D.4995 = length * 4;
  D.4996 = ret + D.4995;
  *D.4996 = 0B;
  D.4987 = ret;
  return D.4987;
}


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

  if (str != 0B) goto <D.4998>; else goto <D.4999>;
  <D.4998>:
  D.5000 = __strdup (str);
  return D.5000;
  <D.4999>:
  D.5000 = 0B;
  return D.5000;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.5004;
  unsigned int length.0;
  unsigned int D.5006;
  gchar * * D.5007;
  gchar * D.5008;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.5002>; else goto <D.5003>;
  <D.5002>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.5004 = 0;
  return D.5004;
  <D.5003>:
  length = 0;
  goto <D.4599>;
  <D.4598>:
  length = length + 1;
  <D.4599>:
  length.0 = (unsigned int) length;
  D.5006 = length.0 * 4;
  D.5007 = str_array + D.5006;
  D.5008 = *D.5007;
  if (D.5008 != 0B) goto <D.4598>; else goto <D.4600>;
  <D.4600>:
  D.5004 = (guint) length;
  return D.5004;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.5012;
  int iftmp.1;
  sizetype D.5019;
  const gchar * D.5020;
  int D.5021;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.5010>; else goto <D.5011>;
  <D.5010>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.5012 = 0;
  return D.5012;
  <D.5011>:
  if (suffix == 0B) goto <D.5013>; else goto <D.5014>;
  <D.5013>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.5012 = 0;
  return D.5012;
  <D.5014>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.5018>; else goto <D.5016>;
  <D.5018>:
  D.5019 = str_length - suffix_length;
  D.5020 = str + D.5019;
  D.5021 = strncmp (D.5020, suffix, suffix_length);
  if (D.5021 == 0) goto <D.5022>; else goto <D.5016>;
  <D.5022>:
  iftmp.1 = 1;
  goto <D.5017>;
  <D.5016>:
  iftmp.1 = 0;
  <D.5017>:
  D.5012 = iftmp.1;
  return D.5012;
}


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

  if (str == 0B) goto <D.5024>; else goto <D.5025>;
  <D.5024>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.5026 = 0;
  return D.5026;
  <D.5025>:
  if (prefix == 0B) goto <D.5027>; else goto <D.5028>;
  <D.5027>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.5026 = 0;
  return D.5026;
  <D.5028>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.5032>; else goto <D.5030>;
  <D.5032>:
  D.5033 = strncmp (str, prefix, prefix_length);
  if (D.5033 == 0) goto <D.5034>; else goto <D.5030>;
  <D.5034>:
  iftmp.2 = 1;
  goto <D.5031>;
  <D.5030>:
  iftmp.2 = 0;
  <D.5031>:
  D.5026 = iftmp.2;
  return D.5026;
}


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

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


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

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


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

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


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

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


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.5053;
  unsigned int D.5054;
  char * args.4;
  char * args.5;
  unsigned int D.5057;
  char * args.6;
  char * args.7;
  unsigned int D.5060;
  char * D.5063;
  char * args.8;
  char * args.9;
  char * args.10;
  char * args.11;
  char * args;
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.5051>; else goto <D.5052>;
      <D.5051>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.5053 = 0B;
      return D.5053;
      <D.5052>:
      D.5054 = strlen (first);
      total = D.5054 + total;
      __builtin_va_start (&args, 0);
      args.4 = args;
      args.5 = args.4 + 4;
      args = args.5;
      s = MEM[(char * *)args.4];
      goto <D.4654>;
      <D.4653>:
      D.5057 = strlen (s);
      total = D.5057 + total;
      args.6 = args;
      args.7 = args.6 + 4;
      args = args.7;
      s = MEM[(char * *)args.6];
      <D.4654>:
      if (s != 0B) goto <D.4653>; else goto <D.4655>;
      <D.4655>:
      __builtin_va_end (&args);
      D.5060 = total + 1;
      ret = monoeg_malloc (D.5060);
      if (ret == 0B) goto <D.5061>; else goto <D.5062>;
      <D.5061>:
      D.5053 = 0B;
      return D.5053;
      <D.5062>:
      D.5063 = ret + total;
      *D.5063 = 0;
      strcpy (ret, first);
      __builtin_va_start (&args, 0);
      args.8 = args;
      args.9 = args.8 + 4;
      args = args.9;
      s = MEM[(char * *)args.8];
      goto <D.4657>;
      <D.4656>:
      strcat (ret, s);
      args.10 = args;
      args.11 = args.10 + 4;
      args = args.11;
      s = MEM[(char * *)args.10];
      <D.4657>:
      if (s != 0B) goto <D.4656>; else goto <D.4658>;
      <D.4658>:
      __builtin_va_end (&args);
      D.5053 = ret;
      return D.5053;
    }
  finally
    {
      args = {CLOBBER};
    }
}


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

  D.5071 = __builtin_object_size (__dest, 1);
  D.5070 = __builtin___strcpy_chk (__dest, __src, D.5071);
  return D.5070;
}


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

  D.5074 = __builtin_object_size (__dest, 1);
  D.5073 = __builtin___strcat_chk (__dest, __src, D.5074);
  return D.5073;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5078;
  char D.5081;
  unsigned int D.5084;
  int D.5085;
  void * vector.12;
  gchar * * vector.13;
  gchar * D.5090;
  unsigned int D.5091;
  unsigned int D.5093;
  int D.5094;
  unsigned int D.5097;
  char D.5099;
  unsigned int D.5101;
  int D.5102;
  int string.14;
  int c.15;
  int D.5107;
  int D.4712;
  unsigned int D.5110;
  _Bool D.5113;
  _Bool D.5114;
  _Bool D.5115;
  int D.4724;
  gchar * D.5120;
  gchar * D.5122;
  void * vector.16;
  sizetype size.17;
  sizetype D.5130;
  sizetype D.5131;
  gchar * * D.5132;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5076>; else goto <D.5077>;
      <D.5076>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.5078 = 0B;
      return D.5078;
      <D.5077>:
      if (delimiter == 0B) goto <D.5079>; else goto <D.5080>;
      <D.5079>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.5078 = 0B;
      return D.5078;
      <D.5080>:
      D.5081 = *delimiter;
      if (D.5081 == 0) goto <D.5082>; else goto <D.5083>;
      <D.5082>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.5078 = 0B;
      return D.5078;
      <D.5083>:
      D.5084 = strlen (delimiter);
      D.5085 = strncmp (string, delimiter, D.5084);
      if (D.5085 == 0) goto <D.5086>; else goto <D.5087>;
      <D.5086>:
      vector.12 = monoeg_malloc (8);
      vector = vector.12;
      vector.13 = vector;
      D.5090 = monoeg_strdup ("");
      *vector.13 = D.5090;
      size = size + 1;
      D.5091 = strlen (delimiter);
      string = string + D.5091;
      goto <D.5092>;
      <D.5087>:
      vector = 0B;
      <D.5092>:
      goto <D.4714>;
      <D.4713>:
      c = string;
      D.5093 = strlen (delimiter);
      D.5094 = strncmp (string, delimiter, D.5093);
      if (D.5094 == 0) goto <D.5095>; else goto <D.5096>;
      <D.5095>:
      token = monoeg_strdup ("");
      D.5097 = strlen (delimiter);
      string = string + D.5097;
      goto <D.5098>;
      <D.5096>:
      goto <D.4701>;
      <D.4700>:
      string = string + 1;
      <D.4701>:
      D.5099 = *string;
      if (D.5099 != 0) goto <D.5100>; else goto <D.4702>;
      <D.5100>:
      D.5101 = strlen (delimiter);
      D.5102 = strncmp (string, delimiter, D.5101);
      if (D.5102 != 0) goto <D.4700>; else goto <D.4702>;
      <D.4702>:
      D.5099 = *string;
      if (D.5099 != 0) goto <D.5103>; else goto <D.5104>;
      <D.5103>:
      {
        gsize toklen;

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

          D.4712 = __builtin_strcmp (string, delimiter);
        }
        if (D.4712 != 0) goto <D.5108>; else goto <D.5109>;
        <D.5108>:
        D.5110 = strlen (delimiter);
        string = string + D.5110;
        <D.5109>:
      }
      goto <D.5111>;
      <D.5104>:
      token = monoeg_strdup (c);
      <D.5111>:
      <D.5098>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.4714>:
      D.5099 = *string;
      if (D.5099 != 0) goto <D.5112>; else goto <D.4715>;
      <D.5112>:
      D.5113 = max_tokens <= 0;
      D.5114 = size < max_tokens;
      D.5115 = D.5113 | D.5114;
      if (D.5115 != 0) goto <D.4713>; else goto <D.4715>;
      <D.4715>:
      D.5099 = *string;
      if (D.5099 != 0) goto <D.5116>; else goto <D.5117>;
      <D.5116>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.4724 = __builtin_strcmp (string, delimiter);
      }
      if (D.4724 == 0) goto <D.5118>; else goto <D.5119>;
      <D.5118>:
      D.5120 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5120);
      goto <D.5121>;
      <D.5119>:
      D.5122 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5122);
      <D.5121>:
      size = size + 1;
      <D.5117>:
      vector.13 = vector;
      if (vector.13 == 0B) goto <D.5123>; else goto <D.5124>;
      <D.5123>:
      vector.16 = monoeg_malloc (8);
      vector = vector.16;
      vector.13 = vector;
      *vector.13 = 0B;
      goto <D.5126>;
      <D.5124>:
      if (size > 0) goto <D.5127>; else goto <D.5128>;
      <D.5127>:
      vector.13 = vector;
      size.17 = (sizetype) size;
      D.5130 = size.17 + 1073741823;
      D.5131 = D.5130 * 4;
      D.5132 = vector.13 + D.5131;
      *D.5132 = 0B;
      <D.5128>:
      <D.5126>:
      D.5078 = vector;
      return D.5078;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.18;
  gchar * * D.5136;
  int D.5140;
  unsigned int D.5141;
  unsigned int D.5142;
  sizetype size.19;
  sizetype D.5144;
  sizetype D.5145;
  gchar * * D.5146;

  D.5136 = *vector;
  if (D.5136 == 0B) goto <D.5137>; else goto <D.5138>;
  <D.5137>:
  iftmp.18 = monoeg_malloc (8);
  goto <D.5139>;
  <D.5138>:
  D.5140 = size + 1;
  D.5141 = (unsigned int) D.5140;
  D.5142 = D.5141 * 4;
  D.5136 = *vector;
  iftmp.18 = monoeg_realloc (D.5136, D.5142);
  <D.5139>:
  *vector = iftmp.18;
  D.5136 = *vector;
  size.19 = (sizetype) size;
  D.5144 = size.19 + 1073741823;
  D.5145 = D.5144 * 4;
  D.5146 = D.5136 + D.5145;
  *D.5146 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5149;
  char D.5152;
  char D.5155;
  int D.5156;
  int D.5157;
  void * vector.20;
  gchar * * vector.21;
  gchar * D.5162;
  int D.5164;
  int string.22;
  int c.23;
  int D.5169;
  _Bool D.5174;
  _Bool D.5175;
  _Bool D.5176;
  _Bool D.5177;
  _Bool D.5178;
  _Bool D.5179;
  gchar * D.5184;
  char D.5186;
  gchar * D.5189;
  gchar * D.5191;
  void * vector.24;
  sizetype size.25;
  sizetype D.5199;
  sizetype D.5200;
  gchar * * D.5201;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5147>; else goto <D.5148>;
      <D.5147>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.5149 = 0B;
      return D.5149;
      <D.5148>:
      if (delimiter == 0B) goto <D.5150>; else goto <D.5151>;
      <D.5150>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.5149 = 0B;
      return D.5149;
      <D.5151>:
      D.5152 = *delimiter;
      if (D.5152 == 0) goto <D.5153>; else goto <D.5154>;
      <D.5153>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.5149 = 0B;
      return D.5149;
      <D.5154>:
      D.5155 = *string;
      D.5156 = (int) D.5155;
      D.5157 = charcmp (D.5156, delimiter);
      if (D.5157 != 0) goto <D.5158>; else goto <D.5159>;
      <D.5158>:
      vector.20 = monoeg_malloc (8);
      vector = vector.20;
      vector.21 = vector;
      D.5162 = monoeg_strdup ("");
      *vector.21 = D.5162;
      size = size + 1;
      string = string + 1;
      goto <D.5163>;
      <D.5159>:
      vector = 0B;
      <D.5163>:
      c = string;
      goto <D.4743>;
      <D.4742>:
      D.5155 = *string;
      D.5156 = (int) D.5155;
      D.5164 = charcmp (D.5156, delimiter);
      if (D.5164 != 0) goto <D.5165>; else goto <D.5166>;
      <D.5165>:
      {
        gsize toklen;

        string.22 = (int) string;
        c.23 = (int) c;
        D.5169 = string.22 - c.23;
        toklen = (gsize) D.5169;
        if (toklen == 0) goto <D.5170>; else goto <D.5171>;
        <D.5170>:
        token = monoeg_strdup ("");
        goto <D.5172>;
        <D.5171>:
        token = monoeg_g_strndup (c, toklen);
        <D.5172>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.5166>:
      string = string + 1;
      <D.4743>:
      D.5155 = *string;
      if (D.5155 != 0) goto <D.5173>; else goto <D.4744>;
      <D.5173>:
      D.5174 = max_tokens <= 0;
      D.5175 = size < max_tokens;
      D.5176 = D.5174 | D.5175;
      if (D.5176 != 0) goto <D.4742>; else goto <D.4744>;
      <D.4744>:
      D.5177 = max_tokens > 0;
      D.5178 = size >= max_tokens;
      D.5179 = D.5177 & D.5178;
      if (D.5179 != 0) goto <D.5180>; else goto <D.5181>;
      <D.5180>:
      D.5155 = *string;
      if (D.5155 != 0) goto <D.5182>; else goto <D.5183>;
      <D.5182>:
      D.5184 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5184);
      size = size + 1;
      <D.5183>:
      goto <D.5185>;
      <D.5181>:
      D.5186 = *c;
      if (D.5186 != 0) goto <D.5187>; else goto <D.5188>;
      <D.5187>:
      D.5189 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.5189);
      size = size + 1;
      goto <D.5190>;
      <D.5188>:
      D.5191 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5191);
      size = size + 1;
      <D.5190>:
      <D.5185>:
      vector.21 = vector;
      if (vector.21 == 0B) goto <D.5192>; else goto <D.5193>;
      <D.5192>:
      vector.24 = monoeg_malloc (8);
      vector = vector.24;
      vector.21 = vector;
      *vector.21 = 0B;
      goto <D.5195>;
      <D.5193>:
      if (size > 0) goto <D.5196>; else goto <D.5197>;
      <D.5196>:
      vector.21 = vector;
      size.25 = (sizetype) size;
      D.5199 = size.25 + 1073741823;
      D.5200 = D.5199 * 4;
      D.5201 = vector.21 + D.5200;
      *D.5201 = 0B;
      <D.5197>:
      <D.5195>:
      D.5149 = vector;
      return D.5149;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.5204;
  gboolean D.5207;

  goto <D.4730>;
  <D.4729>:
  D.5204 = *compare;
  if (D.5204 == testchar) goto <D.5205>; else goto <D.5206>;
  <D.5205>:
  D.5207 = 1;
  return D.5207;
  <D.5206>:
  compare = compare + 1;
  <D.4730>:
  D.5204 = *compare;
  if (D.5204 != 0) goto <D.4729>; else goto <D.4731>;
  <D.4731>:
  D.5207 = 0;
  return D.5207;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.5211;
  char D.5212;
  unsigned int D.5215;
  gchar * D.5216;
  gchar * D.5217;
  char D.5218;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.5209>; else goto <D.5210>;
  <D.5209>:
  D.5211 = 0B;
  return D.5211;
  <D.5210>:
  D.5212 = *str;
  if (D.5212 == 0) goto <D.5213>; else goto <D.5214>;
  <D.5213>:
  D.5211 = str;
  return D.5211;
  <D.5214>:
  i = 0;
  D.5215 = strlen (str);
  j = D.5215 + 4294967295;
  goto <D.4752>;
  <D.4751>:
  D.5216 = str + i;
  c = *D.5216;
  D.5216 = str + i;
  D.5217 = str + j;
  D.5218 = *D.5217;
  *D.5216 = D.5218;
  D.5217 = str + j;
  *D.5217 = c;
  i = i + 1;
  j = j + 4294967295;
  <D.4752>:
  if (i < j) goto <D.4751>; else goto <D.4753>;
  <D.4753>:
  D.5211 = str;
  return D.5211;
}


monoeg_g_strjoin (const gchar * separator)
{
  char * args.26;
  char * args.27;
  unsigned int D.5225;
  char * args.28;
  char * args.29;
  gchar * D.5230;
  _Bool D.5231;
  _Bool D.5232;
  _Bool D.5233;
  unsigned int D.5236;
  char * args.30;
  char * args.31;
  char * args.32;
  char * args.33;
  char * args.34;
  char * args.35;
  char * args;
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.5220>; else goto <D.5221>;
      <D.5220>:
      slen = strlen (separator);
      goto <D.5222>;
      <D.5221>:
      slen = 0;
      <D.5222>:
      len = 0;
      __builtin_va_start (&args, 0);
      args.26 = args;
      args.27 = args.26 + 4;
      args = args.27;
      s = MEM[(char * *)args.26];
      goto <D.4764>;
      <D.4763>:
      D.5225 = strlen (s);
      len = D.5225 + len;
      len = len + slen;
      args.28 = args;
      args.29 = args.28 + 4;
      args = args.29;
      s = MEM[(char * *)args.28];
      <D.4764>:
      if (s != 0B) goto <D.4763>; else goto <D.4765>;
      <D.4765>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.5228>; else goto <D.5229>;
      <D.5228>:
      D.5230 = monoeg_strdup ("");
      return D.5230;
      <D.5229>:
      D.5231 = slen != 0;
      D.5232 = len != 0;
      D.5233 = D.5231 & D.5232;
      if (D.5233 != 0) goto <D.5234>; else goto <D.5235>;
      <D.5234>:
      len = len - slen;
      <D.5235>:
      D.5236 = len + 1;
      res = monoeg_malloc (D.5236);
      __builtin_va_start (&args, 0);
      args.30 = args;
      args.31 = args.30 + 4;
      args = args.31;
      s = MEM[(char * *)args.30];
      r = monoeg_g_stpcpy (res, s);
      args.32 = args;
      args.33 = args.32 + 4;
      args = args.33;
      s = MEM[(char * *)args.32];
      goto <D.4767>;
      <D.4766>:
      if (separator != 0B) goto <D.5241>; else goto <D.5242>;
      <D.5241>:
      r = monoeg_g_stpcpy (r, separator);
      <D.5242>:
      r = monoeg_g_stpcpy (r, s);
      args.34 = args;
      args.35 = args.34 + 4;
      args = args.35;
      s = MEM[(char * *)args.34];
      <D.4767>:
      if (s != 0B) goto <D.4766>; else goto <D.4768>;
      <D.4768>:
      __builtin_va_end (&args);
      D.5230 = res;
      return D.5230;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  unsigned int D.5250;
  gchar * * D.5251;
  gchar * D.5252;
  unsigned int D.5253;
  gchar * D.5256;
  _Bool D.5257;
  _Bool D.5258;
  _Bool D.5259;
  unsigned int D.5262;
  gchar * D.5263;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.5247>; else goto <D.5248>;
  <D.5247>:
  slen = strlen (separator);
  goto <D.5249>;
  <D.5248>:
  slen = 0;
  <D.5249>:
  len = 0;
  i = 0;
  goto <D.4779>;
  <D.4778>:
  D.5250 = i * 4;
  D.5251 = str_array + D.5250;
  D.5252 = *D.5251;
  D.5253 = strlen (D.5252);
  len = D.5253 + len;
  len = len + slen;
  i = i + 1;
  <D.4779>:
  D.5250 = i * 4;
  D.5251 = str_array + D.5250;
  D.5252 = *D.5251;
  if (D.5252 != 0B) goto <D.4778>; else goto <D.4780>;
  <D.4780>:
  if (len == 0) goto <D.5254>; else goto <D.5255>;
  <D.5254>:
  D.5256 = monoeg_strdup ("");
  return D.5256;
  <D.5255>:
  D.5257 = slen != 0;
  D.5258 = len != 0;
  D.5259 = D.5257 & D.5258;
  if (D.5259 != 0) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  len = len - slen;
  <D.5261>:
  D.5262 = len + 1;
  res = monoeg_malloc (D.5262);
  D.5263 = *str_array;
  r = monoeg_g_stpcpy (res, D.5263);
  i = 1;
  goto <D.4782>;
  <D.4781>:
  if (separator != 0B) goto <D.5264>; else goto <D.5265>;
  <D.5264>:
  r = monoeg_g_stpcpy (r, separator);
  <D.5265>:
  D.5250 = i * 4;
  D.5251 = str_array + D.5250;
  D.5252 = *D.5251;
  r = monoeg_g_stpcpy (r, D.5252);
  i = i + 1;
  <D.4782>:
  D.5250 = i * 4;
  D.5251 = str_array + D.5250;
  D.5252 = *D.5251;
  if (D.5252 != 0B) goto <D.4781>; else goto <D.4783>;
  <D.4783>:
  D.5256 = res;
  return D.5256;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.5269;
  char D.5270;
  const short unsigned int * * D.5272;
  const short unsigned int * D.5273;
  unsigned int D.5274;
  unsigned int D.5275;
  const short unsigned int * D.5276;
  short unsigned int D.5277;
  int D.5278;
  int D.5279;
  unsigned int D.5282;
  int str.36;
  int tmp.37;
  int D.5285;
  unsigned int D.5286;
  unsigned int D.5287;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.5267>; else goto <D.5268>;
  <D.5267>:
  D.5269 = 0B;
  return D.5269;
  <D.5268>:
  tmp = str;
  goto <D.4790>;
  <D.4789>:
  tmp = tmp + 1;
  <D.4790>:
  D.5270 = *tmp;
  if (D.5270 != 0) goto <D.5271>; else goto <D.4791>;
  <D.5271>:
  D.5272 = __ctype_b_loc ();
  D.5273 = *D.5272;
  D.5270 = *tmp;
  D.5274 = (unsigned int) D.5270;
  D.5275 = D.5274 * 2;
  D.5276 = D.5273 + D.5275;
  D.5277 = *D.5276;
  D.5278 = (int) D.5277;
  D.5279 = D.5278 & 8192;
  if (D.5279 != 0) goto <D.4789>; else goto <D.4791>;
  <D.4791>:
  if (str != tmp) goto <D.5280>; else goto <D.5281>;
  <D.5280>:
  D.5282 = strlen (str);
  str.36 = (int) str;
  tmp.37 = (int) tmp;
  D.5285 = str.36 - tmp.37;
  D.5286 = (unsigned int) D.5285;
  D.5287 = D.5282 + D.5286;
  len = D.5287 + 1;
  memmove (str, tmp, len);
  <D.5281>:
  D.5269 = str;
  return D.5269;
}


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

  D.5290 = __builtin_object_size (__dest, 0);
  D.5289 = __builtin___memmove_chk (__dest, __src, __len, D.5290);
  return D.5289;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.5294;
  unsigned int D.5295;
  sizetype D.5296;
  char D.5297;
  const short unsigned int * * D.5299;
  const short unsigned int * D.5300;
  unsigned int D.5301;
  unsigned int D.5302;
  const short unsigned int * D.5303;
  short unsigned int D.5304;
  int D.5305;
  int D.5306;
  gchar * D.5307;
  gchar * tmp;

  if (str == 0B) goto <D.5292>; else goto <D.5293>;
  <D.5292>:
  D.5294 = 0B;
  return D.5294;
  <D.5293>:
  D.5295 = strlen (str);
  D.5296 = D.5295 + 4294967295;
  tmp = str + D.5296;
  goto <D.4797>;
  <D.4796>:
  tmp = tmp + 4294967295;
  <D.4797>:
  D.5297 = *tmp;
  if (D.5297 != 0) goto <D.5298>; else goto <D.4798>;
  <D.5298>:
  D.5299 = __ctype_b_loc ();
  D.5300 = *D.5299;
  D.5297 = *tmp;
  D.5301 = (unsigned int) D.5297;
  D.5302 = D.5301 * 2;
  D.5303 = D.5300 + D.5302;
  D.5304 = *D.5303;
  D.5305 = (int) D.5304;
  D.5306 = D.5305 & 8192;
  if (D.5306 != 0) goto <D.4796>; else goto <D.4798>;
  <D.4798>:
  D.5307 = tmp + 1;
  *D.5307 = 0;
  D.5294 = str;
  return D.5294;
}


monoeg_g_printf (const gchar * format)
{
  char * args.38;
  gint D.5310;
  char * args;
  gint ret;

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


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

  stdout.39 = stdout;
  D.5313 = __vfprintf_chk (stdout.39, 1, __fmt, __ap);
  return D.5313;
}


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

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


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

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


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

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


vsprintf (char * restrict __s, const char * restrict __fmt, char * __ap)
{
  int D.5326;
  unsigned int D.5327;

  D.5327 = __builtin_object_size (__s, 1);
  D.5326 = __builtin___vsprintf_chk (__s, 1, D.5327, __fmt, __ap);
  return D.5326;
}


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

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


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, char * __ap)
{
  int D.5333;
  unsigned int D.5334;

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


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.5338;
  int D.5341;
  struct GError * D.5346;
  unsigned int D.5347;
  char D.5348;
  int D.5349;
  int D.5350;
  unsigned int D.5354;
  int D.5355;
  char * rp.43;
  char * rp.44;
  unsigned char D.5360;
  unsigned char D.5361;
  int D.5362;
  char D.5363;
  char * rp.45;
  int D.5365;
  int D.5366;
  char D.5367;
  char * rp.46;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.5336>; else goto <D.5337>;
  <D.5336>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.5338 = 0B;
  return D.5338;
  <D.5337>:
  if (hostname != 0B) goto <D.5339>; else goto <D.5340>;
  <D.5339>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.5340>:
  D.5341 = monoeg_g_path_is_absolute (filename);
  if (D.5341 == 0) goto <D.5342>; else goto <D.5343>;
  <D.5342>:
  if (error != 0B) goto <D.5344>; else goto <D.5345>;
  <D.5344>:
  D.5346 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.5346;
  <D.5345>:
  D.5338 = 0B;
  return D.5338;
  <D.5343>:
  D.5347 = strlen (uriPrefix);
  n = D.5347 + 1;
  p = filename;
  goto <D.4838>;
  <D.4837>:
  D.5348 = *p;
  D.5349 = (int) D.5348;
  D.5350 = char_needs_encoding (D.5349);
  if (D.5350 != 0) goto <D.5351>; else goto <D.5352>;
  <D.5351>:
  n = n + 3;
  goto <D.5353>;
  <D.5352>:
  n = n + 1;
  <D.5353>:
  p = p + 1;
  <D.4838>:
  D.5348 = *p;
  if (D.5348 != 0) goto <D.4837>; else goto <D.4839>;
  <D.4839>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.5354 = strlen (ret);
  rp = ret + D.5354;
  goto <D.4841>;
  <D.4840>:
  D.5348 = *p;
  D.5349 = (int) D.5348;
  D.5355 = char_needs_encoding (D.5349);
  if (D.5355 != 0) goto <D.5356>; else goto <D.5357>;
  <D.5356>:
  rp.43 = rp;
  rp = rp.43 + 1;
  *rp.43 = 37;
  rp.44 = rp;
  rp = rp.44 + 1;
  D.5348 = *p;
  D.5360 = (unsigned char) D.5348;
  D.5361 = D.5360 >> 4;
  D.5362 = (int) D.5361;
  D.5363 = hx[D.5362];
  *rp.44 = D.5363;
  rp.45 = rp;
  rp = rp.45 + 1;
  D.5348 = *p;
  D.5360 = (unsigned char) D.5348;
  D.5365 = (int) D.5360;
  D.5366 = D.5365 & 15;
  D.5367 = hx[D.5366];
  *rp.45 = D.5367;
  goto <D.5368>;
  <D.5357>:
  rp.46 = rp;
  rp = rp.46 + 1;
  D.5348 = *p;
  *rp.46 = D.5348;
  <D.5368>:
  p = p + 1;
  <D.4841>:
  D.5348 = *p;
  if (D.5348 != 0) goto <D.4840>; else goto <D.4842>;
  <D.4842>:
  *rp = 0;
  D.5338 = ret;
  return D.5338;
}


char_needs_encoding (char c)
{
  gboolean D.5373;
  unsigned char c.47;
  unsigned char D.5377;
  _Bool D.5378;
  unsigned char D.5379;
  _Bool D.5380;
  _Bool D.5381;
  unsigned char D.5383;
  _Bool D.5385;
  _Bool D.5386;
  _Bool D.5387;
  _Bool D.5389;
  _Bool D.5390;
  _Bool D.5391;

  if (c < 0) goto <D.5371>; else goto <D.5372>;
  <D.5371>:
  D.5373 = 1;
  return D.5373;
  <D.5372>:
  c.47 = (unsigned char) c;
  D.5377 = c.47 + 192;
  D.5378 = D.5377 <= 26;
  c.47 = (unsigned char) c;
  D.5379 = c.47 + 159;
  D.5380 = D.5379 <= 25;
  D.5381 = D.5378 | D.5380;
  if (D.5381 != 0) goto <D.5374>; else goto <D.5382>;
  <D.5382>:
  c.47 = (unsigned char) c;
  D.5383 = c.47 + 218;
  if (D.5383 <= 20) goto <D.5374>; else goto <D.5384>;
  <D.5384>:
  D.5385 = c == 33;
  D.5386 = c == 36;
  D.5387 = D.5385 | D.5386;
  if (D.5387 != 0) goto <D.5374>; else goto <D.5388>;
  <D.5388>:
  D.5389 = c == 95;
  D.5390 = c == 61;
  D.5391 = D.5389 | D.5390;
  if (D.5391 != 0) goto <D.5374>; else goto <D.5392>;
  <D.5392>:
  if (c == 126) goto <D.5374>; else goto <D.5375>;
  <D.5374>:
  D.5373 = 0;
  return D.5373;
  <D.5375>:
  D.5373 = 1;
  return D.5373;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.5396;
  int D.5399;
  struct GError * D.5404;
  char D.5405;
  const char * D.5410;
  char D.5411;
  const char * D.5413;
  char D.5414;
  const short unsigned int * * D.5416;
  const short unsigned int * D.5417;
  unsigned int D.5418;
  unsigned int D.5419;
  const short unsigned int * D.5420;
  short unsigned int D.5421;
  int D.5422;
  int D.5423;
  unsigned int D.5425;
  unsigned int D.5426;
  const short unsigned int * D.5427;
  short unsigned int D.5428;
  int D.5429;
  int D.5430;
  struct GError * D.5434;
  int D.5435;
  unsigned int D.5436;
  sizetype flen.48;
  char * D.5438;
  char * r.49;
  int D.5442;
  int D.5443;
  int D.5444;
  char D.5445;
  int D.5446;
  int D.5447;
  char D.5448;
  char D.5449;
  char * r.50;
  const char * p;
  char * r;
  char * result;
  int flen;

  flen = 0;
  if (uri == 0B) goto <D.5394>; else goto <D.5395>;
  <D.5394>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 629, "uri != NULL");
  D.5396 = 0B;
  return D.5396;
  <D.5395>:
  if (hostname != 0B) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_from_uri: hostname not handled");
  <D.5398>:
  D.5399 = strncmp (uri, "file:///", 8);
  if (D.5399 != 0) goto <D.5400>; else goto <D.5401>;
  <D.5400>:
  if (error != 0B) goto <D.5402>; else goto <D.5403>;
  <D.5402>:
  D.5404 = monoeg_g_error_new (0B, 2, "URI does not start with the file: scheme");
  *error = D.5404;
  <D.5403>:
  D.5396 = 0B;
  return D.5396;
  <D.5401>:
  p = uri + 8;
  goto <D.4865>;
  <D.4864>:
  D.5405 = *p;
  if (D.5405 == 37) goto <D.5406>; else goto <D.5407>;
  <D.5406>:
  D.5410 = p + 1;
  D.5411 = *D.5410;
  if (D.5411 != 0) goto <D.5412>; else goto <D.5408>;
  <D.5412>:
  D.5413 = p + 2;
  D.5414 = *D.5413;
  if (D.5414 != 0) goto <D.5415>; else goto <D.5408>;
  <D.5415>:
  D.5416 = __ctype_b_loc ();
  D.5417 = *D.5416;
  D.5410 = p + 1;
  D.5411 = *D.5410;
  D.5418 = (unsigned int) D.5411;
  D.5419 = D.5418 * 2;
  D.5420 = D.5417 + D.5419;
  D.5421 = *D.5420;
  D.5422 = (int) D.5421;
  D.5423 = D.5422 & 4096;
  if (D.5423 != 0) goto <D.5424>; else goto <D.5408>;
  <D.5424>:
  D.5416 = __ctype_b_loc ();
  D.5417 = *D.5416;
  D.5413 = p + 2;
  D.5414 = *D.5413;
  D.5425 = (unsigned int) D.5414;
  D.5426 = D.5425 * 2;
  D.5427 = D.5417 + D.5426;
  D.5428 = *D.5427;
  D.5429 = (int) D.5428;
  D.5430 = D.5429 & 4096;
  if (D.5430 != 0) goto <D.5431>; else goto <D.5408>;
  <D.5431>:
  p = p + 2;
  goto <D.5409>;
  <D.5408>:
  if (error != 0B) goto <D.5432>; else goto <D.5433>;
  <D.5432>:
  D.5434 = monoeg_g_error_new (0B, 2, "URI contains an invalid escape sequence");
  *error = D.5434;
  <D.5433>:
  D.5396 = 0B;
  return D.5396;
  <D.5409>:
  <D.5407>:
  flen = flen + 1;
  p = p + 1;
  <D.4865>:
  D.5405 = *p;
  if (D.5405 != 0) goto <D.4864>; else goto <D.4866>;
  <D.4866>:
  flen = flen + 1;
  D.5435 = flen + 1;
  D.5436 = (unsigned int) D.5435;
  result = monoeg_malloc (D.5436);
  flen.48 = (sizetype) flen;
  D.5438 = result + flen.48;
  *D.5438 = 0;
  *result = 47;
  r = result + 1;
  p = uri + 8;
  goto <D.4868>;
  <D.4867>:
  D.5405 = *p;
  if (D.5405 == 37) goto <D.5439>; else goto <D.5440>;
  <D.5439>:
  r.49 = r;
  r = r.49 + 1;
  D.5410 = p + 1;
  D.5411 = *D.5410;
  D.5442 = (int) D.5411;
  D.5443 = decode (D.5442);
  D.5444 = D.5443 << 4;
  D.5445 = (char) D.5444;
  D.5413 = p + 2;
  D.5414 = *D.5413;
  D.5446 = (int) D.5414;
  D.5447 = decode (D.5446);
  D.5448 = (char) D.5447;
  D.5449 = D.5445 | D.5448;
  *r.49 = D.5449;
  p = p + 2;
  goto <D.5450>;
  <D.5440>:
  r.50 = r;
  r = r.50 + 1;
  D.5405 = *p;
  *r.50 = D.5405;
  <D.5450>:
  flen = flen + 1;
  p = p + 1;
  <D.4868>:
  D.5405 = *p;
  if (D.5405 != 0) goto <D.4867>; else goto <D.4869>;
  <D.4869>:
  D.5396 = result;
  return D.5396;
}


decode (char p)
{
  unsigned char p.51;
  unsigned char D.5454;
  int D.5457;
  int D.5458;
  unsigned char D.5459;
  unsigned char D.5462;

  p.51 = (unsigned char) p;
  D.5454 = p.51 + 208;
  if (D.5454 <= 9) goto <D.5455>; else goto <D.5456>;
  <D.5455>:
  D.5458 = (int) p;
  D.5457 = D.5458 + -48;
  return D.5457;
  <D.5456>:
  p.51 = (unsigned char) p;
  D.5459 = p.51 + 191;
  if (D.5459 <= 5) goto <D.5460>; else goto <D.5461>;
  <D.5460>:
  D.5458 = (int) p;
  D.5457 = D.5458 + -65;
  return D.5457;
  <D.5461>:
  p.51 = (unsigned char) p;
  D.5462 = p.51 + 159;
  if (D.5462 <= 5) goto <D.5463>; else goto <D.5464>;
  <D.5463>:
  D.5458 = (int) p;
  D.5457 = D.5458 + -97;
  return D.5457;
  <D.5464>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gstr.c", 618);
  D.5457 = 0;
  return D.5457;
}


monoeg_g_strdown (gchar * string)
{
  int D.4875;
  char D.5470;
  int D.5471;
  int D.5472;
  const int iftmp.52;
  unsigned int __c.53;
  unsigned int D.5477;
  const __int32_t * * D.5480;
  const __int32_t * D.5481;
  unsigned int __c.54;
  unsigned int D.5483;
  const __int32_t * D.5484;
  unsigned int D.5488;
  unsigned int D.5489;
  const __int32_t * D.5490;
  char D.5491;

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

    {
      if (0 != 0) goto <D.5468>; else goto <D.5469>;
      <D.5468>:
      D.5470 = *string;
      D.5471 = (int) D.5470;
      D.5472 = __builtin_constant_p (D.5471);
      if (D.5472 != 0) goto <D.5473>; else goto <D.5474>;
      <D.5473>:
      {
        int __c;

        D.5470 = *string;
        __c = (int) D.5470;
        __c.53 = (unsigned int) __c;
        D.5477 = __c.53 + 128;
        if (D.5477 <= 383) goto <D.5478>; else goto <D.5479>;
        <D.5478>:
        D.5480 = __ctype_tolower_loc ();
        D.5481 = *D.5480;
        __c.54 = (unsigned int) __c;
        D.5483 = __c.54 * 4;
        D.5484 = D.5481 + D.5483;
        iftmp.52 = *D.5484;
        goto <D.5485>;
        <D.5479>:
        iftmp.52 = __c;
        <D.5485>:
        __res = iftmp.52;
      }
      goto <D.5486>;
      <D.5474>:
      D.5470 = *string;
      D.5471 = (int) D.5470;
      __res = tolower (D.5471);
      <D.5486>:
      goto <D.5487>;
      <D.5469>:
      D.5480 = __ctype_tolower_loc ();
      D.5481 = *D.5480;
      D.5470 = *string;
      D.5488 = (unsigned int) D.5470;
      D.5489 = D.5488 * 4;
      D.5490 = D.5481 + D.5489;
      __res = *D.5490;
      <D.5487>:
    }
    D.4875 = __res;
  }
  D.5491 = (char) D.4875;
  *string = D.5491;
  string = string + 1;
  <D.4877>:
  D.5470 = *string;
  if (D.5470 != 0) goto <D.4876>; else goto <D.4878>;
  <D.4878>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.5493;
  gchar iftmp.55;
  unsigned char c.56;
  unsigned char D.5496;
  unsigned char D.5499;

  c.56 = (unsigned char) c;
  D.5496 = c.56 + 191;
  if (D.5496 <= 25) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  c.56 = (unsigned char) c;
  D.5499 = c.56 + 32;
  iftmp.55 = (gchar) D.5499;
  goto <D.5500>;
  <D.5498>:
  iftmp.55 = c;
  <D.5500>:
  D.5493 = iftmp.55;
  return D.5493;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.5504;
  unsigned int D.5507;
  int D.5508;
  unsigned int D.5509;
  sizetype i.57;
  char * D.5511;
  const gchar * D.5512;
  char D.5513;
  int D.5514;
  char D.5515;
  char * ret;
  int i;

  if (str == 0B) goto <D.5502>; else goto <D.5503>;
  <D.5502>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.5504 = 0B;
  return D.5504;
  <D.5503>:
  if (len == -1) goto <D.5505>; else goto <D.5506>;
  <D.5505>:
  D.5507 = strlen (str);
  len = (gssize) D.5507;
  <D.5506>:
  D.5508 = len + 1;
  D.5509 = (unsigned int) D.5508;
  ret = monoeg_malloc (D.5509);
  i = 0;
  goto <D.4889>;
  <D.4888>:
  i.57 = (sizetype) i;
  D.5511 = ret + i.57;
  i.57 = (sizetype) i;
  D.5512 = str + i.57;
  D.5513 = *D.5512;
  D.5514 = (int) D.5513;
  D.5515 = monoeg_g_ascii_tolower (D.5514);
  *D.5511 = D.5515;
  i = i + 1;
  <D.4889>:
  if (i < len) goto <D.4888>; else goto <D.4890>;
  <D.4890>:
  i.57 = (sizetype) i;
  D.5511 = ret + i.57;
  *D.5511 = 0;
  D.5504 = ret;
  return D.5504;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.5517;
  gchar iftmp.58;
  unsigned char c.59;
  unsigned char D.5520;
  unsigned char D.5523;

  c.59 = (unsigned char) c;
  D.5520 = c.59 + 159;
  if (D.5520 <= 25) goto <D.5521>; else goto <D.5522>;
  <D.5521>:
  c.59 = (unsigned char) c;
  D.5523 = c.59 + 224;
  iftmp.58 = (gchar) D.5523;
  goto <D.5524>;
  <D.5522>:
  iftmp.58 = c;
  <D.5524>:
  D.5517 = iftmp.58;
  return D.5517;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.5528;
  unsigned int D.5531;
  int D.5532;
  unsigned int D.5533;
  sizetype i.60;
  char * D.5535;
  const gchar * D.5536;
  char D.5537;
  int D.5538;
  char D.5539;
  char * ret;
  int i;

  if (str == 0B) goto <D.5526>; else goto <D.5527>;
  <D.5526>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.5528 = 0B;
  return D.5528;
  <D.5527>:
  if (len == -1) goto <D.5529>; else goto <D.5530>;
  <D.5529>:
  D.5531 = strlen (str);
  len = (gssize) D.5531;
  <D.5530>:
  D.5532 = len + 1;
  D.5533 = (unsigned int) D.5532;
  ret = monoeg_malloc (D.5533);
  i = 0;
  goto <D.4901>;
  <D.4900>:
  i.60 = (sizetype) i;
  D.5535 = ret + i.60;
  i.60 = (sizetype) i;
  D.5536 = str + i.60;
  D.5537 = *D.5536;
  D.5538 = (int) D.5537;
  D.5539 = monoeg_ascii_toupper (D.5538);
  *D.5535 = D.5539;
  i = i + 1;
  <D.4901>:
  if (i < len) goto <D.4900>; else goto <D.4902>;
  <D.4902>:
  i.60 = (sizetype) i;
  D.5535 = ret + i.60;
  *D.5535 = 0;
  D.5528 = ret;
  return D.5528;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.5543;
  const gchar * s1.61;
  char D.5547;
  int D.5548;
  const gchar * s2.62;
  char D.5550;
  int D.5551;
  int D.5554;
  int D.5555;
  gsize i;

  if (s1 == 0B) goto <D.5541>; else goto <D.5542>;
  <D.5541>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.5543 = 0;
  return D.5543;
  <D.5542>:
  if (s2 == 0B) goto <D.5544>; else goto <D.5545>;
  <D.5544>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.5543 = 0;
  return D.5543;
  <D.5545>:
  i = 0;
  goto <D.4912>;
  <D.4911>:
  {
    gchar c1;
    gchar c2;

    s1.61 = s1;
    s1 = s1.61 + 1;
    D.5547 = *s1.61;
    D.5548 = (int) D.5547;
    c1 = monoeg_g_ascii_tolower (D.5548);
    s2.62 = s2;
    s2 = s2.62 + 1;
    D.5550 = *s2.62;
    D.5551 = (int) D.5550;
    c2 = monoeg_g_ascii_tolower (D.5551);
    if (c1 != c2) goto <D.5552>; else goto <D.5553>;
    <D.5552>:
    D.5554 = (int) c1;
    D.5555 = (int) c2;
    D.5543 = D.5554 - D.5555;
    return D.5543;
    <D.5553>:
  }
  i = i + 1;
  <D.4912>:
  if (i < n) goto <D.4911>; else goto <D.4913>;
  <D.4913>:
  D.5543 = 0;
  return D.5543;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.5559;
  const char * sp1.63;
  char D.5563;
  int D.5564;
  const char * sp2.64;
  char D.5566;
  int D.5567;
  int D.5570;
  int D.5571;
  char D.5572;
  int D.5573;
  char D.5574;
  int D.5575;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.5557>; else goto <D.5558>;
  <D.5557>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.5559 = 0;
  return D.5559;
  <D.5558>:
  if (s2 == 0B) goto <D.5560>; else goto <D.5561>;
  <D.5560>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.5559 = 0;
  return D.5559;
  <D.5561>:
  goto <D.4923>;
  <D.4922>:
  {
    char c1;
    char c2;

    sp1.63 = sp1;
    sp1 = sp1.63 + 1;
    D.5563 = *sp1.63;
    D.5564 = (int) D.5563;
    c1 = monoeg_g_ascii_tolower (D.5564);
    sp2.64 = sp2;
    sp2 = sp2.64 + 1;
    D.5566 = *sp2.64;
    D.5567 = (int) D.5566;
    c2 = monoeg_g_ascii_tolower (D.5567);
    if (c1 != c2) goto <D.5568>; else goto <D.5569>;
    <D.5568>:
    D.5570 = (int) c1;
    D.5571 = (int) c2;
    D.5559 = D.5570 - D.5571;
    return D.5559;
    <D.5569>:
  }
  <D.4923>:
  D.5572 = *sp1;
  if (D.5572 != 0) goto <D.4922>; else goto <D.4924>;
  <D.4924>:
  D.5572 = *sp1;
  D.5573 = (int) D.5572;
  D.5574 = *sp2;
  D.5575 = (int) D.5574;
  D.5559 = D.5573 - D.5575;
  return D.5559;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.5579;
  _Bool iftmp.65;
  char D.5585;
  int D.5586;
  int D.5587;
  void * D.5590;
  char * D.5591;
  gchar * ptr;

  if (string == 0B) goto <D.5577>; else goto <D.5578>;
  <D.5577>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.5579 = 0B;
  return D.5579;
  <D.5578>:
  if (delimiters == 0B) goto <D.5580>; else goto <D.5581>;
  <D.5580>:
  delimiters = "_-|> <.";
  <D.5581>:
  ptr = string;
  goto <D.4932>;
  <D.4931>:
  D.5585 = *ptr;
  D.5586 = (int) D.5585;
  D.5587 = __builtin_constant_p (D.5586);
  if (D.5587 != 0) goto <D.5588>; else goto <D.5583>;
  <D.5588>:
  D.5585 = *ptr;
  if (D.5585 == 0) goto <D.5589>; else goto <D.5583>;
  <D.5589>:
  D.5585 = *ptr;
  D.5586 = (int) D.5585;
  D.5590 = __rawmemchr (delimiters, D.5586);
  iftmp.65 = D.5590 != 0B;
  goto <D.5584>;
  <D.5583>:
  D.5585 = *ptr;
  D.5586 = (int) D.5585;
  D.5591 = __builtin_strchr (delimiters, D.5586);
  iftmp.65 = D.5591 != 0B;
  <D.5584>:
  if (iftmp.65 != 0) goto <D.5592>; else goto <D.5593>;
  <D.5592>:
  *ptr = new_delimiter;
  <D.5593>:
  ptr = ptr + 1;
  <D.4932>:
  D.5585 = *ptr;
  if (D.5585 != 0) goto <D.4931>; else goto <D.4933>;
  <D.4933>:
  D.5579 = string;
  return D.5579;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.5597;
  const gchar * s.66;
  gchar * d.67;
  unsigned int D.5606;
  const gchar * s.68;
  char D.5608;
  int s.69;
  int src.70;
  int D.5611;
  int D.5612;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.5595>; else goto <D.5596>;
  <D.5595>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.5597 = 0;
  return D.5597;
  <D.5596>:
  if (dest == 0B) goto <D.5598>; else goto <D.5599>;
  <D.5598>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.5597 = 0;
  return D.5597;
  <D.5599>:
  len = dest_size;
  if (len == 0) goto <D.5600>; else goto <D.5601>;
  <D.5600>:
  D.5597 = 0;
  return D.5597;
  <D.5601>:
  s = src;
  d = dest;
  goto <D.4944>;
  <D.4943>:
  s.66 = s;
  s = s.66 + 1;
  c = *s.66;
  d.67 = d;
  d = d.67 + 1;
  *d.67 = c;
  if (c == 0) goto <D.5604>; else goto <D.5605>;
  <D.5604>:
  D.5606 = dest_size - len;
  D.5597 = D.5606 + 4294967295;
  return D.5597;
  <D.5605>:
  <D.4944>:
  len = len + 4294967295;
  if (len != 0) goto <D.4943>; else goto <D.4945>;
  <D.4945>:
  *d = 0;
  goto <D.4947>;
  <D.4946>:
  <D.4947>:
  s.68 = s;
  s = s.68 + 1;
  D.5608 = *s.68;
  if (D.5608 != 0) goto <D.4946>; else goto <D.4948>;
  <D.4948>:
  s.69 = (int) s;
  src.70 = (int) src;
  D.5611 = s.69 - src.70;
  D.5612 = D.5611 + -1;
  D.5597 = (gsize) D.5612;
  return D.5597;
}


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

  if (dest == 0B) goto <D.5614>; else goto <D.5615>;
  <D.5614>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.5616 = dest;
  return D.5616;
  <D.5615>:
  if (src == 0B) goto <D.5617>; else goto <D.5618>;
  <D.5617>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.5616 = dest;
  return D.5616;
  <D.5618>:
  D.5616 = stpcpy (dest, src);
  return D.5616;
}


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

  D.5621 = __builtin_object_size (__dest, 1);
  D.5620 = __builtin___stpcpy_chk (__dest, __src, D.5621);
  return D.5620;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.5625;
  char D.5628;
  int D.5629;
  unsigned int D.5630;
  unsigned int D.5631;
  unsigned int D.5632;
  int D.5633;
  gchar * res_ptr.71;
  gchar * res_ptr.72;
  gchar * res_ptr.73;
  gchar * res_ptr.74;
  unsigned char c.75;
  unsigned char D.5645;
  unsigned char D.5646;
  char D.5647;
  gchar * res_ptr.76;
  signed char D.5649;
  unsigned char D.5650;
  unsigned char D.5651;
  unsigned char D.5652;
  char D.5653;
  gchar * res_ptr.77;
  unsigned char D.5655;
  unsigned char D.5656;
  char D.5657;
  gchar escaped[256];
  const gchar * ptr;
  gchar c;
  gchar op;
  gchar * result;
  gchar * res_ptr;

  try
    {
      if (source == 0B) goto <D.5623>; else goto <D.5624>;
      <D.5623>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.5625 = 0B;
      return D.5625;
      <D.5624>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.5626>; else goto <D.5627>;
      <D.5626>:
      ptr = exceptions;
      goto <D.4965>;
      <D.4964>:
      D.5628 = *ptr;
      D.5629 = (int) D.5628;
      escaped[D.5629] = 0;
      ptr = ptr + 1;
      <D.4965>:
      D.5628 = *ptr;
      if (D.5628 != 0) goto <D.4964>; else goto <D.4966>;
      <D.4966>:
      <D.5627>:
      D.5630 = strlen (source);
      D.5631 = D.5630 * 4;
      D.5632 = D.5631 + 1;
      result = monoeg_malloc (D.5632);
      res_ptr = result;
      ptr = source;
      goto <D.4968>;
      <D.4967>:
      c = *ptr;
      D.5633 = (int) c;
      op = escaped[D.5633];
      if (op == 0) goto <D.5634>; else goto <D.5635>;
      <D.5634>:
      res_ptr.71 = res_ptr;
      res_ptr = res_ptr.71 + 1;
      *res_ptr.71 = c;
      goto <D.5637>;
      <D.5635>:
      res_ptr.72 = res_ptr;
      res_ptr = res_ptr.72 + 1;
      *res_ptr.72 = 92;
      if (op != 1) goto <D.5639>; else goto <D.5640>;
      <D.5639>:
      res_ptr.73 = res_ptr;
      res_ptr = res_ptr.73 + 1;
      *res_ptr.73 = op;
      goto <D.5642>;
      <D.5640>:
      res_ptr.74 = res_ptr;
      res_ptr = res_ptr.74 + 1;
      c.75 = (unsigned char) c;
      D.5645 = c.75 >> 6;
      D.5646 = D.5645 + 48;
      D.5647 = (char) D.5646;
      *res_ptr.74 = D.5647;
      res_ptr.76 = res_ptr;
      res_ptr = res_ptr.76 + 1;
      D.5649 = c >> 3;
      D.5650 = (unsigned char) D.5649;
      D.5651 = D.5650 & 7;
      D.5652 = D.5651 + 48;
      D.5653 = (char) D.5652;
      *res_ptr.76 = D.5653;
      res_ptr.77 = res_ptr;
      res_ptr = res_ptr.77 + 1;
      c.75 = (unsigned char) c;
      D.5655 = c.75 & 7;
      D.5656 = D.5655 + 48;
      D.5657 = (char) D.5656;
      *res_ptr.77 = D.5657;
      <D.5642>:
      <D.5637>:
      ptr = ptr + 1;
      <D.4968>:
      D.5628 = *ptr;
      if (D.5628 != 0) goto <D.4967>; else goto <D.4969>;
      <D.4969>:
      *res_ptr = 0;
      D.5625 = result;
      return D.5625;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


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

  D.5661 = __builtin_object_size (__dest, 0);
  D.5660 = __builtin___memcpy_chk (__dest, __src, __len, D.5661);
  return D.5660;
}


monoeg_g_ascii_xdigit_value (gchar c)
{
  gint D.5663;
  gint iftmp.78;
  const short unsigned int * * D.5665;
  const short unsigned int * D.5666;
  unsigned int D.5667;
  unsigned int D.5668;
  const short unsigned int * D.5669;
  short unsigned int D.5670;
  int D.5671;
  int D.5672;
  gint iftmp.79;
  unsigned char c.80;
  unsigned char D.5677;
  int D.5680;
  gint iftmp.81;
  unsigned char D.5683;

  D.5665 = __ctype_b_loc ();
  D.5666 = *D.5665;
  D.5667 = (unsigned int) c;
  D.5668 = D.5667 * 2;
  D.5669 = D.5666 + D.5668;
  D.5670 = *D.5669;
  D.5671 = (int) D.5670;
  D.5672 = D.5671 & 4096;
  if (D.5672 != 0) goto <D.5673>; else goto <D.5674>;
  <D.5673>:
  c.80 = (unsigned char) c;
  D.5677 = c.80 + 208;
  if (D.5677 <= 9) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  D.5680 = (int) c;
  iftmp.79 = D.5680 + -48;
  goto <D.5681>;
  <D.5679>:
  c.80 = (unsigned char) c;
  D.5683 = c.80 + 159;
  if (D.5683 <= 5) goto <D.5684>; else goto <D.5685>;
  <D.5684>:
  D.5680 = (int) c;
  iftmp.81 = D.5680 + -87;
  goto <D.5686>;
  <D.5685>:
  D.5680 = (int) c;
  iftmp.81 = D.5680 + -55;
  <D.5686>:
  iftmp.79 = iftmp.81;
  <D.5681>:
  iftmp.78 = iftmp.79;
  goto <D.5687>;
  <D.5674>:
  iftmp.78 = -1;
  <D.5687>:
  D.5663 = iftmp.78;
  return D.5663;
}


monoeg_g_strnfill (gsize length, gchar fill_char)
{
  unsigned int D.5689;
  int D.5690;
  gchar * D.5691;
  gchar * D.5692;
  gchar * ret;

  D.5689 = length + 1;
  ret = monoeg_malloc (D.5689);
  D.5690 = (int) fill_char;
  memset (ret, D.5690, length);
  D.5691 = ret + length;
  *D.5691 = 0;
  D.5692 = ret;
  return D.5692;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5696;
  int D.5701;
  void * D.5703;
  unsigned int D.5704;

  D.5696 = __builtin_constant_p (__len);
  if (D.5696 != 0) goto <D.5697>; else goto <D.5698>;
  <D.5697>:
  if (__len == 0) goto <D.5699>; else goto <D.5700>;
  <D.5699>:
  D.5701 = __builtin_constant_p (__ch);
  if (D.5701 == 0) goto <D.5694>; else goto <D.5702>;
  <D.5702>:
  if (__ch != 0) goto <D.5694>; else goto <D.5695>;
  <D.5694>:
  __warn_memset_zero_len ();
  D.5703 = __dest;
  return D.5703;
  <D.5695>:
  <D.5700>:
  <D.5698>:
  D.5704 = __builtin_object_size (__dest, 0);
  D.5703 = __builtin___memset_chk (__dest, __ch, __len, D.5704);
  return D.5703;
}