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

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


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

  orig = str_array;
  if (str_array == 0B) goto <D.5001>; else goto <D.5002>;
  <D.5001>:
  return;
  <D.5002>:
  goto <D.4603>;
  <D.4602>:
  D.5003 = *str_array;
  monoeg_g_free (D.5003);
  str_array = str_array + 4;
  <D.4603>:
  D.5003 = *str_array;
  if (D.5003 != 0B) goto <D.4602>; else goto <D.4604>;
  <D.4604>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.5007;
  unsigned int D.5008;
  unsigned int D.5009;
  unsigned int D.5010;
  gchar * * D.5011;
  gchar * * D.5012;
  gchar * D.5013;
  gchar * D.5014;
  unsigned int D.5015;
  gchar * * D.5016;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.5005>; else goto <D.5006>;
  <D.5005>:
  D.5007 = 0B;
  return D.5007;
  <D.5006>:
  length = monoeg_g_strv_length (str_array);
  D.5008 = length + 1;
  D.5009 = D.5008 * 4;
  ret = monoeg_malloc0 (D.5009);
  i = 0;
  goto <D.4612>;
  <D.4611>:
  D.5010 = i * 4;
  D.5011 = ret + D.5010;
  D.5010 = i * 4;
  D.5012 = str_array + D.5010;
  D.5013 = *D.5012;
  D.5014 = monoeg_strdup (D.5013);
  *D.5011 = D.5014;
  i = i + 1;
  <D.4612>:
  D.5010 = i * 4;
  D.5012 = str_array + D.5010;
  D.5013 = *D.5012;
  if (D.5013 != 0B) goto <D.4611>; else goto <D.4613>;
  <D.4613>:
  D.5015 = length * 4;
  D.5016 = ret + D.5015;
  *D.5016 = 0B;
  D.5007 = ret;
  return D.5007;
}


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

  if (str != 0B) goto <D.5018>; else goto <D.5019>;
  <D.5018>:
  D.5020 = __strdup (str);
  return D.5020;
  <D.5019>:
  D.5020 = 0B;
  return D.5020;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.5024;
  unsigned int length.0;
  unsigned int D.5026;
  gchar * * D.5027;
  gchar * D.5028;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.5022>; else goto <D.5023>;
  <D.5022>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.5024 = 0;
  return D.5024;
  <D.5023>:
  length = 0;
  goto <D.4619>;
  <D.4618>:
  length = length + 1;
  <D.4619>:
  length.0 = (unsigned int) length;
  D.5026 = length.0 * 4;
  D.5027 = str_array + D.5026;
  D.5028 = *D.5027;
  if (D.5028 != 0B) goto <D.4618>; else goto <D.4620>;
  <D.4620>:
  D.5024 = (guint) length;
  return D.5024;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.5032;
  int iftmp.1;
  sizetype D.5039;
  const gchar * D.5040;
  int D.5041;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.5030>; else goto <D.5031>;
  <D.5030>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.5032 = 0;
  return D.5032;
  <D.5031>:
  if (suffix == 0B) goto <D.5033>; else goto <D.5034>;
  <D.5033>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.5032 = 0;
  return D.5032;
  <D.5034>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.5038>; else goto <D.5036>;
  <D.5038>:
  D.5039 = str_length - suffix_length;
  D.5040 = str + D.5039;
  D.5041 = strncmp (D.5040, suffix, suffix_length);
  if (D.5041 == 0) goto <D.5042>; else goto <D.5036>;
  <D.5042>:
  iftmp.1 = 1;
  goto <D.5037>;
  <D.5036>:
  iftmp.1 = 0;
  <D.5037>:
  D.5032 = iftmp.1;
  return D.5032;
}


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

  if (str == 0B) goto <D.5044>; else goto <D.5045>;
  <D.5044>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.5046 = 0;
  return D.5046;
  <D.5045>:
  if (prefix == 0B) goto <D.5047>; else goto <D.5048>;
  <D.5047>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.5046 = 0;
  return D.5046;
  <D.5048>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.5052>; else goto <D.5050>;
  <D.5052>:
  D.5053 = strncmp (str, prefix, prefix_length);
  if (D.5053 == 0) goto <D.5054>; else goto <D.5050>;
  <D.5054>:
  iftmp.2 = 1;
  goto <D.5051>;
  <D.5050>:
  iftmp.2 = 0;
  <D.5051>:
  D.5046 = iftmp.2;
  return D.5046;
}


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

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


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

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


monoeg_g_strdup_printf (const gchar * format)
{
  void * args.3;
  gchar * D.5066;
  gchar * ret;
  void * 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.5064>; else goto <D.5065>;
      <D.5064>:
      D.5066 = 0B;
      return D.5066;
      <D.5065>:
      D.5066 = ret;
      return D.5066;
    }
  finally
    {
      ret = {CLOBBER};
      args = {CLOBBER};
    }
}


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

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


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.5073;
  unsigned int D.5074;
  void * args.4;
  void * args.5;
  unsigned int D.5077;
  void * args.6;
  void * args.7;
  unsigned int D.5080;
  char * D.5083;
  void * args.8;
  void * args.9;
  void * args.10;
  void * args.11;
  void * args;
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.5071>; else goto <D.5072>;
      <D.5071>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.5073 = 0B;
      return D.5073;
      <D.5072>:
      D.5074 = strlen (first);
      total = D.5074 + total;
      __builtin_va_start (&args, 0);
      args.4 = args;
      args.5 = args.4 + 4;
      args = args.5;
      s = MEM[(char * *)args.4];
      goto <D.4674>;
      <D.4673>:
      D.5077 = strlen (s);
      total = D.5077 + total;
      args.6 = args;
      args.7 = args.6 + 4;
      args = args.7;
      s = MEM[(char * *)args.6];
      <D.4674>:
      if (s != 0B) goto <D.4673>; else goto <D.4675>;
      <D.4675>:
      __builtin_va_end (&args);
      D.5080 = total + 1;
      ret = monoeg_malloc (D.5080);
      if (ret == 0B) goto <D.5081>; else goto <D.5082>;
      <D.5081>:
      D.5073 = 0B;
      return D.5073;
      <D.5082>:
      D.5083 = ret + total;
      *D.5083 = 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.4677>;
      <D.4676>:
      strcat (ret, s);
      args.10 = args;
      args.11 = args.10 + 4;
      args = args.11;
      s = MEM[(char * *)args.10];
      <D.4677>:
      if (s != 0B) goto <D.4676>; else goto <D.4678>;
      <D.4678>:
      __builtin_va_end (&args);
      D.5073 = ret;
      return D.5073;
    }
  finally
    {
      args = {CLOBBER};
    }
}


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

  D.5091 = __builtin_object_size (__dest, 1);
  D.5090 = __builtin___strcpy_chk (__dest, __src, D.5091);
  return D.5090;
}


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

  D.5094 = __builtin_object_size (__dest, 1);
  D.5093 = __builtin___strcat_chk (__dest, __src, D.5094);
  return D.5093;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5098;
  char D.5101;
  unsigned int D.5104;
  int D.5105;
  void * vector.12;
  gchar * * vector.13;
  gchar * D.5110;
  unsigned int D.5111;
  unsigned int D.5113;
  int D.5114;
  unsigned int D.5117;
  char D.5119;
  unsigned int D.5121;
  int D.5122;
  int string.14;
  int c.15;
  int D.5127;
  int D.4732;
  unsigned int D.5130;
  int D.4744;
  gchar * D.5138;
  gchar * D.5140;
  void * vector.16;
  sizetype size.17;
  sizetype D.5148;
  sizetype D.5149;
  gchar * * D.5150;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5096>; else goto <D.5097>;
      <D.5096>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.5098 = 0B;
      return D.5098;
      <D.5097>:
      if (delimiter == 0B) goto <D.5099>; else goto <D.5100>;
      <D.5099>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.5098 = 0B;
      return D.5098;
      <D.5100>:
      D.5101 = *delimiter;
      if (D.5101 == 0) goto <D.5102>; else goto <D.5103>;
      <D.5102>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.5098 = 0B;
      return D.5098;
      <D.5103>:
      D.5104 = strlen (delimiter);
      D.5105 = strncmp (string, delimiter, D.5104);
      if (D.5105 == 0) goto <D.5106>; else goto <D.5107>;
      <D.5106>:
      vector.12 = monoeg_malloc (8);
      vector = vector.12;
      vector.13 = vector;
      D.5110 = monoeg_strdup ("");
      *vector.13 = D.5110;
      size = size + 1;
      D.5111 = strlen (delimiter);
      string = string + D.5111;
      goto <D.5112>;
      <D.5107>:
      vector = 0B;
      <D.5112>:
      goto <D.4734>;
      <D.4733>:
      c = string;
      D.5113 = strlen (delimiter);
      D.5114 = strncmp (string, delimiter, D.5113);
      if (D.5114 == 0) goto <D.5115>; else goto <D.5116>;
      <D.5115>:
      token = monoeg_strdup ("");
      D.5117 = strlen (delimiter);
      string = string + D.5117;
      goto <D.5118>;
      <D.5116>:
      goto <D.4721>;
      <D.4720>:
      string = string + 1;
      <D.4721>:
      D.5119 = *string;
      if (D.5119 != 0) goto <D.5120>; else goto <D.4722>;
      <D.5120>:
      D.5121 = strlen (delimiter);
      D.5122 = strncmp (string, delimiter, D.5121);
      if (D.5122 != 0) goto <D.4720>; else goto <D.4722>;
      <D.4722>:
      D.5119 = *string;
      if (D.5119 != 0) goto <D.5123>; else goto <D.5124>;
      <D.5123>:
      {
        gsize toklen;

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

          D.4732 = __builtin_strcmp (string, delimiter);
        }
        if (D.4732 != 0) goto <D.5128>; else goto <D.5129>;
        <D.5128>:
        D.5130 = strlen (delimiter);
        string = string + D.5130;
        <D.5129>:
      }
      goto <D.5131>;
      <D.5124>:
      token = monoeg_strdup (c);
      <D.5131>:
      <D.5118>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.4734>:
      D.5119 = *string;
      if (D.5119 != 0) goto <D.5132>; else goto <D.4735>;
      <D.5132>:
      if (max_tokens <= 0) goto <D.4733>; else goto <D.5133>;
      <D.5133>:
      if (size < max_tokens) goto <D.4733>; else goto <D.4735>;
      <D.4735>:
      D.5119 = *string;
      if (D.5119 != 0) goto <D.5134>; else goto <D.5135>;
      <D.5134>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.4744 = __builtin_strcmp (string, delimiter);
      }
      if (D.4744 == 0) goto <D.5136>; else goto <D.5137>;
      <D.5136>:
      D.5138 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5138);
      goto <D.5139>;
      <D.5137>:
      D.5140 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5140);
      <D.5139>:
      size = size + 1;
      <D.5135>:
      vector.13 = vector;
      if (vector.13 == 0B) goto <D.5141>; else goto <D.5142>;
      <D.5141>:
      vector.16 = monoeg_malloc (8);
      vector = vector.16;
      vector.13 = vector;
      *vector.13 = 0B;
      goto <D.5144>;
      <D.5142>:
      if (size > 0) goto <D.5145>; else goto <D.5146>;
      <D.5145>:
      vector.13 = vector;
      size.17 = (sizetype) size;
      D.5148 = size.17 + 1073741823;
      D.5149 = D.5148 * 4;
      D.5150 = vector.13 + D.5149;
      *D.5150 = 0B;
      <D.5146>:
      <D.5144>:
      D.5098 = vector;
      return D.5098;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.18;
  gchar * * D.5154;
  int D.5158;
  unsigned int D.5159;
  unsigned int D.5160;
  sizetype size.19;
  sizetype D.5162;
  sizetype D.5163;
  gchar * * D.5164;

  D.5154 = *vector;
  if (D.5154 == 0B) goto <D.5155>; else goto <D.5156>;
  <D.5155>:
  iftmp.18 = monoeg_malloc (8);
  goto <D.5157>;
  <D.5156>:
  D.5154 = *vector;
  D.5158 = size + 1;
  D.5159 = (unsigned int) D.5158;
  D.5160 = D.5159 * 4;
  iftmp.18 = monoeg_realloc (D.5154, D.5160);
  <D.5157>:
  *vector = iftmp.18;
  D.5154 = *vector;
  size.19 = (sizetype) size;
  D.5162 = size.19 + 1073741823;
  D.5163 = D.5162 * 4;
  D.5164 = D.5154 + D.5163;
  *D.5164 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5167;
  char D.5170;
  char D.5173;
  int D.5174;
  int D.5175;
  void * vector.20;
  gchar * * vector.21;
  gchar * D.5180;
  int D.5182;
  int string.22;
  int c.23;
  int D.5187;
  gchar * D.5199;
  char D.5200;
  gchar * D.5203;
  gchar * D.5205;
  void * vector.24;
  sizetype size.25;
  sizetype D.5213;
  sizetype D.5214;
  gchar * * D.5215;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5165>; else goto <D.5166>;
      <D.5165>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.5167 = 0B;
      return D.5167;
      <D.5166>:
      if (delimiter == 0B) goto <D.5168>; else goto <D.5169>;
      <D.5168>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.5167 = 0B;
      return D.5167;
      <D.5169>:
      D.5170 = *delimiter;
      if (D.5170 == 0) goto <D.5171>; else goto <D.5172>;
      <D.5171>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.5167 = 0B;
      return D.5167;
      <D.5172>:
      D.5173 = *string;
      D.5174 = (int) D.5173;
      D.5175 = charcmp (D.5174, delimiter);
      if (D.5175 != 0) goto <D.5176>; else goto <D.5177>;
      <D.5176>:
      vector.20 = monoeg_malloc (8);
      vector = vector.20;
      vector.21 = vector;
      D.5180 = monoeg_strdup ("");
      *vector.21 = D.5180;
      size = size + 1;
      string = string + 1;
      goto <D.5181>;
      <D.5177>:
      vector = 0B;
      <D.5181>:
      c = string;
      goto <D.4763>;
      <D.4762>:
      D.5173 = *string;
      D.5174 = (int) D.5173;
      D.5182 = charcmp (D.5174, delimiter);
      if (D.5182 != 0) goto <D.5183>; else goto <D.5184>;
      <D.5183>:
      {
        gsize toklen;

        string.22 = (int) string;
        c.23 = (int) c;
        D.5187 = string.22 - c.23;
        toklen = (gsize) D.5187;
        if (toklen == 0) goto <D.5188>; else goto <D.5189>;
        <D.5188>:
        token = monoeg_strdup ("");
        goto <D.5190>;
        <D.5189>:
        token = monoeg_g_strndup (c, toklen);
        <D.5190>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.5184>:
      string = string + 1;
      <D.4763>:
      D.5173 = *string;
      if (D.5173 != 0) goto <D.5191>; else goto <D.4764>;
      <D.5191>:
      if (max_tokens <= 0) goto <D.4762>; else goto <D.5192>;
      <D.5192>:
      if (size < max_tokens) goto <D.4762>; else goto <D.4764>;
      <D.4764>:
      if (max_tokens > 0) goto <D.5195>; else goto <D.5193>;
      <D.5195>:
      if (size >= max_tokens) goto <D.5196>; else goto <D.5193>;
      <D.5196>:
      D.5173 = *string;
      if (D.5173 != 0) goto <D.5197>; else goto <D.5198>;
      <D.5197>:
      D.5199 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5199);
      size = size + 1;
      <D.5198>:
      goto <D.5194>;
      <D.5193>:
      D.5200 = *c;
      if (D.5200 != 0) goto <D.5201>; else goto <D.5202>;
      <D.5201>:
      D.5203 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.5203);
      size = size + 1;
      goto <D.5204>;
      <D.5202>:
      D.5205 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5205);
      size = size + 1;
      <D.5204>:
      <D.5194>:
      vector.21 = vector;
      if (vector.21 == 0B) goto <D.5206>; else goto <D.5207>;
      <D.5206>:
      vector.24 = monoeg_malloc (8);
      vector = vector.24;
      vector.21 = vector;
      *vector.21 = 0B;
      goto <D.5209>;
      <D.5207>:
      if (size > 0) goto <D.5210>; else goto <D.5211>;
      <D.5210>:
      vector.21 = vector;
      size.25 = (sizetype) size;
      D.5213 = size.25 + 1073741823;
      D.5214 = D.5213 * 4;
      D.5215 = vector.21 + D.5214;
      *D.5215 = 0B;
      <D.5211>:
      <D.5209>:
      D.5167 = vector;
      return D.5167;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.5218;
  gboolean D.5221;

  goto <D.4750>;
  <D.4749>:
  D.5218 = *compare;
  if (D.5218 == testchar) goto <D.5219>; else goto <D.5220>;
  <D.5219>:
  D.5221 = 1;
  return D.5221;
  <D.5220>:
  compare = compare + 1;
  <D.4750>:
  D.5218 = *compare;
  if (D.5218 != 0) goto <D.4749>; else goto <D.4751>;
  <D.4751>:
  D.5221 = 0;
  return D.5221;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.5225;
  char D.5226;
  unsigned int D.5229;
  gchar * D.5230;
  gchar * D.5231;
  char D.5232;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.5223>; else goto <D.5224>;
  <D.5223>:
  D.5225 = 0B;
  return D.5225;
  <D.5224>:
  D.5226 = *str;
  if (D.5226 == 0) goto <D.5227>; else goto <D.5228>;
  <D.5227>:
  D.5225 = str;
  return D.5225;
  <D.5228>:
  i = 0;
  D.5229 = strlen (str);
  j = D.5229 + 4294967295;
  goto <D.4772>;
  <D.4771>:
  D.5230 = str + i;
  c = *D.5230;
  D.5230 = str + i;
  D.5231 = str + j;
  D.5232 = *D.5231;
  *D.5230 = D.5232;
  D.5231 = str + j;
  *D.5231 = c;
  i = i + 1;
  j = j + 4294967295;
  <D.4772>:
  if (i < j) goto <D.4771>; else goto <D.4773>;
  <D.4773>:
  D.5225 = str;
  return D.5225;
}


monoeg_g_strjoin (const gchar * separator)
{
  void * args.26;
  void * args.27;
  unsigned int D.5239;
  void * args.28;
  void * args.29;
  gchar * D.5244;
  unsigned int D.5249;
  void * args.30;
  void * args.31;
  void * args.32;
  void * args.33;
  void * args.34;
  void * args.35;
  void * args;
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.5234>; else goto <D.5235>;
      <D.5234>:
      slen = strlen (separator);
      goto <D.5236>;
      <D.5235>:
      slen = 0;
      <D.5236>:
      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.4784>;
      <D.4783>:
      D.5239 = strlen (s);
      len = D.5239 + len;
      len = len + slen;
      args.28 = args;
      args.29 = args.28 + 4;
      args = args.29;
      s = MEM[(char * *)args.28];
      <D.4784>:
      if (s != 0B) goto <D.4783>; else goto <D.4785>;
      <D.4785>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.5242>; else goto <D.5243>;
      <D.5242>:
      D.5244 = monoeg_strdup ("");
      return D.5244;
      <D.5243>:
      if (slen != 0) goto <D.5245>; else goto <D.5246>;
      <D.5245>:
      if (len != 0) goto <D.5247>; else goto <D.5248>;
      <D.5247>:
      len = len - slen;
      <D.5248>:
      <D.5246>:
      D.5249 = len + 1;
      res = monoeg_malloc (D.5249);
      __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.4787>;
      <D.4786>:
      if (separator != 0B) goto <D.5254>; else goto <D.5255>;
      <D.5254>:
      r = monoeg_g_stpcpy (r, separator);
      <D.5255>:
      r = monoeg_g_stpcpy (r, s);
      args.34 = args;
      args.35 = args.34 + 4;
      args = args.35;
      s = MEM[(char * *)args.34];
      <D.4787>:
      if (s != 0B) goto <D.4786>; else goto <D.4788>;
      <D.4788>:
      __builtin_va_end (&args);
      D.5244 = res;
      return D.5244;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  unsigned int D.5263;
  gchar * * D.5264;
  gchar * D.5265;
  unsigned int D.5266;
  gchar * D.5269;
  unsigned int D.5274;
  gchar * D.5275;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  slen = strlen (separator);
  goto <D.5262>;
  <D.5261>:
  slen = 0;
  <D.5262>:
  len = 0;
  i = 0;
  goto <D.4799>;
  <D.4798>:
  D.5263 = i * 4;
  D.5264 = str_array + D.5263;
  D.5265 = *D.5264;
  D.5266 = strlen (D.5265);
  len = D.5266 + len;
  len = len + slen;
  i = i + 1;
  <D.4799>:
  D.5263 = i * 4;
  D.5264 = str_array + D.5263;
  D.5265 = *D.5264;
  if (D.5265 != 0B) goto <D.4798>; else goto <D.4800>;
  <D.4800>:
  if (len == 0) goto <D.5267>; else goto <D.5268>;
  <D.5267>:
  D.5269 = monoeg_strdup ("");
  return D.5269;
  <D.5268>:
  if (slen != 0) goto <D.5270>; else goto <D.5271>;
  <D.5270>:
  if (len != 0) goto <D.5272>; else goto <D.5273>;
  <D.5272>:
  len = len - slen;
  <D.5273>:
  <D.5271>:
  D.5274 = len + 1;
  res = monoeg_malloc (D.5274);
  D.5275 = *str_array;
  r = monoeg_g_stpcpy (res, D.5275);
  i = 1;
  goto <D.4802>;
  <D.4801>:
  if (separator != 0B) goto <D.5276>; else goto <D.5277>;
  <D.5276>:
  r = monoeg_g_stpcpy (r, separator);
  <D.5277>:
  D.5263 = i * 4;
  D.5264 = str_array + D.5263;
  D.5265 = *D.5264;
  r = monoeg_g_stpcpy (r, D.5265);
  i = i + 1;
  <D.4802>:
  D.5263 = i * 4;
  D.5264 = str_array + D.5263;
  D.5265 = *D.5264;
  if (D.5265 != 0B) goto <D.4801>; else goto <D.4803>;
  <D.4803>:
  D.5269 = res;
  return D.5269;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.5281;
  char D.5282;
  const short unsigned int * * D.5284;
  const short unsigned int * D.5285;
  unsigned int D.5286;
  unsigned int D.5287;
  const short unsigned int * D.5288;
  short unsigned int D.5289;
  int D.5290;
  int D.5291;
  unsigned int D.5294;
  int str.36;
  int tmp.37;
  int D.5297;
  unsigned int D.5298;
  unsigned int D.5299;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.5279>; else goto <D.5280>;
  <D.5279>:
  D.5281 = 0B;
  return D.5281;
  <D.5280>:
  tmp = str;
  goto <D.4810>;
  <D.4809>:
  tmp = tmp + 1;
  <D.4810>:
  D.5282 = *tmp;
  if (D.5282 != 0) goto <D.5283>; else goto <D.4811>;
  <D.5283>:
  D.5284 = __ctype_b_loc ();
  D.5285 = *D.5284;
  D.5282 = *tmp;
  D.5286 = (unsigned int) D.5282;
  D.5287 = D.5286 * 2;
  D.5288 = D.5285 + D.5287;
  D.5289 = *D.5288;
  D.5290 = (int) D.5289;
  D.5291 = D.5290 & 8192;
  if (D.5291 != 0) goto <D.4809>; else goto <D.4811>;
  <D.4811>:
  if (str != tmp) goto <D.5292>; else goto <D.5293>;
  <D.5292>:
  D.5294 = strlen (str);
  str.36 = (int) str;
  tmp.37 = (int) tmp;
  D.5297 = str.36 - tmp.37;
  D.5298 = (unsigned int) D.5297;
  D.5299 = D.5294 + D.5298;
  len = D.5299 + 1;
  memmove (str, tmp, len);
  <D.5293>:
  D.5281 = str;
  return D.5281;
}


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

  D.5302 = __builtin_object_size (__dest, 0);
  D.5301 = __builtin___memmove_chk (__dest, __src, __len, D.5302);
  return D.5301;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.5306;
  unsigned int D.5307;
  sizetype D.5308;
  char D.5309;
  const short unsigned int * * D.5311;
  const short unsigned int * D.5312;
  unsigned int D.5313;
  unsigned int D.5314;
  const short unsigned int * D.5315;
  short unsigned int D.5316;
  int D.5317;
  int D.5318;
  gchar * D.5319;
  gchar * tmp;

  if (str == 0B) goto <D.5304>; else goto <D.5305>;
  <D.5304>:
  D.5306 = 0B;
  return D.5306;
  <D.5305>:
  D.5307 = strlen (str);
  D.5308 = D.5307 + 4294967295;
  tmp = str + D.5308;
  goto <D.4817>;
  <D.4816>:
  tmp = tmp + 4294967295;
  <D.4817>:
  D.5309 = *tmp;
  if (D.5309 != 0) goto <D.5310>; else goto <D.4818>;
  <D.5310>:
  D.5311 = __ctype_b_loc ();
  D.5312 = *D.5311;
  D.5309 = *tmp;
  D.5313 = (unsigned int) D.5309;
  D.5314 = D.5313 * 2;
  D.5315 = D.5312 + D.5314;
  D.5316 = *D.5315;
  D.5317 = (int) D.5316;
  D.5318 = D.5317 & 8192;
  if (D.5318 != 0) goto <D.4816>; else goto <D.4818>;
  <D.4818>:
  D.5319 = tmp + 1;
  *D.5319 = 0;
  D.5306 = str;
  return D.5306;
}


monoeg_g_printf (const gchar * format)
{
  void * args.38;
  gint D.5322;
  void * args;
  gint ret;

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


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

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


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

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


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

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


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

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


vsprintf (char * restrict __s, const char * restrict __fmt, void * __ap)
{
  int D.5338;
  unsigned int D.5339;

  D.5339 = __builtin_object_size (__s, 1);
  D.5338 = __builtin___vsprintf_chk (__s, 1, D.5339, __fmt, __ap);
  return D.5338;
}


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

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


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, void * __ap)
{
  int D.5345;
  unsigned int D.5346;

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


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.5350;
  int D.5353;
  struct GError * D.5358;
  unsigned int D.5359;
  char D.5360;
  int D.5361;
  int D.5362;
  unsigned int D.5366;
  int D.5367;
  char * rp.43;
  char * rp.44;
  unsigned char D.5372;
  unsigned char D.5373;
  int D.5374;
  char D.5375;
  char * rp.45;
  int D.5377;
  int D.5378;
  char D.5379;
  char * rp.46;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.5350 = 0B;
  return D.5350;
  <D.5349>:
  if (hostname != 0B) goto <D.5351>; else goto <D.5352>;
  <D.5351>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.5352>:
  D.5353 = monoeg_g_path_is_absolute (filename);
  if (D.5353 == 0) goto <D.5354>; else goto <D.5355>;
  <D.5354>:
  if (error != 0B) goto <D.5356>; else goto <D.5357>;
  <D.5356>:
  D.5358 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.5358;
  <D.5357>:
  D.5350 = 0B;
  return D.5350;
  <D.5355>:
  D.5359 = strlen (uriPrefix);
  n = D.5359 + 1;
  p = filename;
  goto <D.4858>;
  <D.4857>:
  D.5360 = *p;
  D.5361 = (int) D.5360;
  D.5362 = char_needs_encoding (D.5361);
  if (D.5362 != 0) goto <D.5363>; else goto <D.5364>;
  <D.5363>:
  n = n + 3;
  goto <D.5365>;
  <D.5364>:
  n = n + 1;
  <D.5365>:
  p = p + 1;
  <D.4858>:
  D.5360 = *p;
  if (D.5360 != 0) goto <D.4857>; else goto <D.4859>;
  <D.4859>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.5366 = strlen (ret);
  rp = ret + D.5366;
  goto <D.4861>;
  <D.4860>:
  D.5360 = *p;
  D.5361 = (int) D.5360;
  D.5367 = char_needs_encoding (D.5361);
  if (D.5367 != 0) goto <D.5368>; else goto <D.5369>;
  <D.5368>:
  rp.43 = rp;
  rp = rp.43 + 1;
  *rp.43 = 37;
  rp.44 = rp;
  rp = rp.44 + 1;
  D.5360 = *p;
  D.5372 = (unsigned char) D.5360;
  D.5373 = D.5372 >> 4;
  D.5374 = (int) D.5373;
  D.5375 = hx[D.5374];
  *rp.44 = D.5375;
  rp.45 = rp;
  rp = rp.45 + 1;
  D.5360 = *p;
  D.5372 = (unsigned char) D.5360;
  D.5377 = (int) D.5372;
  D.5378 = D.5377 & 15;
  D.5379 = hx[D.5378];
  *rp.45 = D.5379;
  goto <D.5380>;
  <D.5369>:
  rp.46 = rp;
  rp = rp.46 + 1;
  D.5360 = *p;
  *rp.46 = D.5360;
  <D.5380>:
  p = p + 1;
  <D.4861>:
  D.5360 = *p;
  if (D.5360 != 0) goto <D.4860>; else goto <D.4862>;
  <D.4862>:
  *rp = 0;
  D.5350 = ret;
  return D.5350;
}


char_needs_encoding (char c)
{
  gboolean D.5385;
  unsigned char c.47;
  unsigned char D.5389;
  unsigned char D.5391;
  unsigned char D.5393;

  if (c < 0) goto <D.5383>; else goto <D.5384>;
  <D.5383>:
  D.5385 = 1;
  return D.5385;
  <D.5384>:
  c.47 = (unsigned char) c;
  D.5389 = c.47 + 192;
  if (D.5389 <= 26) goto <D.5386>; else goto <D.5390>;
  <D.5390>:
  c.47 = (unsigned char) c;
  D.5391 = c.47 + 159;
  if (D.5391 <= 25) goto <D.5386>; else goto <D.5392>;
  <D.5392>:
  c.47 = (unsigned char) c;
  D.5393 = c.47 + 218;
  if (D.5393 <= 20) goto <D.5386>; else goto <D.5394>;
  <D.5394>:
  if (c == 33) goto <D.5386>; else goto <D.5395>;
  <D.5395>:
  if (c == 36) goto <D.5386>; else goto <D.5396>;
  <D.5396>:
  if (c == 95) goto <D.5386>; else goto <D.5397>;
  <D.5397>:
  if (c == 61) goto <D.5386>; else goto <D.5398>;
  <D.5398>:
  if (c == 126) goto <D.5386>; else goto <D.5387>;
  <D.5386>:
  D.5385 = 0;
  return D.5385;
  <D.5387>:
  D.5385 = 1;
  return D.5385;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.5402;
  int D.5405;
  struct GError * D.5410;
  char D.5411;
  const char * D.5416;
  char D.5417;
  const char * D.5419;
  char D.5420;
  const short unsigned int * * D.5422;
  const short unsigned int * D.5423;
  unsigned int D.5424;
  unsigned int D.5425;
  const short unsigned int * D.5426;
  short unsigned int D.5427;
  int D.5428;
  int D.5429;
  unsigned int D.5431;
  unsigned int D.5432;
  const short unsigned int * D.5433;
  short unsigned int D.5434;
  int D.5435;
  int D.5436;
  struct GError * D.5440;
  int D.5441;
  unsigned int D.5442;
  sizetype flen.48;
  char * D.5444;
  char * r.49;
  int D.5448;
  int D.5449;
  int D.5450;
  char D.5451;
  int D.5452;
  int D.5453;
  char D.5454;
  char D.5455;
  char * r.50;
  const char * p;
  char * r;
  char * result;
  int flen;

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


decode (char p)
{
  unsigned char p.51;
  unsigned char D.5460;
  int D.5463;
  int D.5464;
  unsigned char D.5465;
  unsigned char D.5468;

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


monoeg_g_strdown (gchar * string)
{
  int D.4895;
  char D.5476;
  int D.5477;
  int D.5478;
  const int iftmp.52;
  unsigned int __c.53;
  unsigned int D.5483;
  const __int32_t * * D.5486;
  const __int32_t * D.5487;
  unsigned int __c.54;
  unsigned int D.5489;
  const __int32_t * D.5490;
  unsigned int D.5494;
  unsigned int D.5495;
  const __int32_t * D.5496;
  char D.5497;

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

    {
      if (0 != 0) goto <D.5474>; else goto <D.5475>;
      <D.5474>:
      D.5476 = *string;
      D.5477 = (int) D.5476;
      D.5478 = __builtin_constant_p (D.5477);
      if (D.5478 != 0) goto <D.5479>; else goto <D.5480>;
      <D.5479>:
      {
        int __c;

        D.5476 = *string;
        __c = (int) D.5476;
        __c.53 = (unsigned int) __c;
        D.5483 = __c.53 + 128;
        if (D.5483 <= 383) goto <D.5484>; else goto <D.5485>;
        <D.5484>:
        D.5486 = __ctype_tolower_loc ();
        D.5487 = *D.5486;
        __c.54 = (unsigned int) __c;
        D.5489 = __c.54 * 4;
        D.5490 = D.5487 + D.5489;
        iftmp.52 = *D.5490;
        goto <D.5491>;
        <D.5485>:
        iftmp.52 = __c;
        <D.5491>:
        __res = iftmp.52;
      }
      goto <D.5492>;
      <D.5480>:
      D.5476 = *string;
      D.5477 = (int) D.5476;
      __res = tolower (D.5477);
      <D.5492>:
      goto <D.5493>;
      <D.5475>:
      D.5486 = __ctype_tolower_loc ();
      D.5487 = *D.5486;
      D.5476 = *string;
      D.5494 = (unsigned int) D.5476;
      D.5495 = D.5494 * 4;
      D.5496 = D.5487 + D.5495;
      __res = *D.5496;
      <D.5493>:
    }
    D.4895 = __res;
  }
  D.5497 = (char) D.4895;
  *string = D.5497;
  string = string + 1;
  <D.4897>:
  D.5476 = *string;
  if (D.5476 != 0) goto <D.4896>; else goto <D.4898>;
  <D.4898>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.5499;
  gchar iftmp.55;
  unsigned char c.56;
  unsigned char D.5502;
  unsigned char D.5505;

  c.56 = (unsigned char) c;
  D.5502 = c.56 + 191;
  if (D.5502 <= 25) goto <D.5503>; else goto <D.5504>;
  <D.5503>:
  c.56 = (unsigned char) c;
  D.5505 = c.56 + 32;
  iftmp.55 = (gchar) D.5505;
  goto <D.5506>;
  <D.5504>:
  iftmp.55 = c;
  <D.5506>:
  D.5499 = iftmp.55;
  return D.5499;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.5510;
  unsigned int D.5513;
  int D.5514;
  unsigned int D.5515;
  sizetype i.57;
  char * D.5517;
  const gchar * D.5518;
  char D.5519;
  int D.5520;
  char D.5521;
  char * ret;
  int i;

  if (str == 0B) goto <D.5508>; else goto <D.5509>;
  <D.5508>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.5510 = 0B;
  return D.5510;
  <D.5509>:
  if (len == -1) goto <D.5511>; else goto <D.5512>;
  <D.5511>:
  D.5513 = strlen (str);
  len = (gssize) D.5513;
  <D.5512>:
  D.5514 = len + 1;
  D.5515 = (unsigned int) D.5514;
  ret = monoeg_malloc (D.5515);
  i = 0;
  goto <D.4909>;
  <D.4908>:
  i.57 = (sizetype) i;
  D.5517 = ret + i.57;
  i.57 = (sizetype) i;
  D.5518 = str + i.57;
  D.5519 = *D.5518;
  D.5520 = (int) D.5519;
  D.5521 = monoeg_g_ascii_tolower (D.5520);
  *D.5517 = D.5521;
  i = i + 1;
  <D.4909>:
  if (i < len) goto <D.4908>; else goto <D.4910>;
  <D.4910>:
  i.57 = (sizetype) i;
  D.5517 = ret + i.57;
  *D.5517 = 0;
  D.5510 = ret;
  return D.5510;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.5523;
  gchar iftmp.58;
  unsigned char c.59;
  unsigned char D.5526;
  unsigned char D.5529;

  c.59 = (unsigned char) c;
  D.5526 = c.59 + 159;
  if (D.5526 <= 25) goto <D.5527>; else goto <D.5528>;
  <D.5527>:
  c.59 = (unsigned char) c;
  D.5529 = c.59 + 224;
  iftmp.58 = (gchar) D.5529;
  goto <D.5530>;
  <D.5528>:
  iftmp.58 = c;
  <D.5530>:
  D.5523 = iftmp.58;
  return D.5523;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.5534;
  unsigned int D.5537;
  int D.5538;
  unsigned int D.5539;
  sizetype i.60;
  char * D.5541;
  const gchar * D.5542;
  char D.5543;
  int D.5544;
  char D.5545;
  char * ret;
  int i;

  if (str == 0B) goto <D.5532>; else goto <D.5533>;
  <D.5532>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.5534 = 0B;
  return D.5534;
  <D.5533>:
  if (len == -1) goto <D.5535>; else goto <D.5536>;
  <D.5535>:
  D.5537 = strlen (str);
  len = (gssize) D.5537;
  <D.5536>:
  D.5538 = len + 1;
  D.5539 = (unsigned int) D.5538;
  ret = monoeg_malloc (D.5539);
  i = 0;
  goto <D.4921>;
  <D.4920>:
  i.60 = (sizetype) i;
  D.5541 = ret + i.60;
  i.60 = (sizetype) i;
  D.5542 = str + i.60;
  D.5543 = *D.5542;
  D.5544 = (int) D.5543;
  D.5545 = monoeg_ascii_toupper (D.5544);
  *D.5541 = D.5545;
  i = i + 1;
  <D.4921>:
  if (i < len) goto <D.4920>; else goto <D.4922>;
  <D.4922>:
  i.60 = (sizetype) i;
  D.5541 = ret + i.60;
  *D.5541 = 0;
  D.5534 = ret;
  return D.5534;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.5549;
  const gchar * s1.61;
  char D.5553;
  int D.5554;
  const gchar * s2.62;
  char D.5556;
  int D.5557;
  int D.5560;
  int D.5561;
  gsize i;

  if (s1 == 0B) goto <D.5547>; else goto <D.5548>;
  <D.5547>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.5549 = 0;
  return D.5549;
  <D.5548>:
  if (s2 == 0B) goto <D.5550>; else goto <D.5551>;
  <D.5550>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.5549 = 0;
  return D.5549;
  <D.5551>:
  i = 0;
  goto <D.4932>;
  <D.4931>:
  {
    gchar c1;
    gchar c2;

    s1.61 = s1;
    s1 = s1.61 + 1;
    D.5553 = *s1.61;
    D.5554 = (int) D.5553;
    c1 = monoeg_g_ascii_tolower (D.5554);
    s2.62 = s2;
    s2 = s2.62 + 1;
    D.5556 = *s2.62;
    D.5557 = (int) D.5556;
    c2 = monoeg_g_ascii_tolower (D.5557);
    if (c1 != c2) goto <D.5558>; else goto <D.5559>;
    <D.5558>:
    D.5560 = (int) c1;
    D.5561 = (int) c2;
    D.5549 = D.5560 - D.5561;
    return D.5549;
    <D.5559>:
  }
  i = i + 1;
  <D.4932>:
  if (i < n) goto <D.4931>; else goto <D.4933>;
  <D.4933>:
  D.5549 = 0;
  return D.5549;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.5565;
  const char * sp1.63;
  char D.5569;
  int D.5570;
  const char * sp2.64;
  char D.5572;
  int D.5573;
  int D.5576;
  int D.5577;
  char D.5578;
  int D.5579;
  char D.5580;
  int D.5581;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.5565 = 0;
  return D.5565;
  <D.5564>:
  if (s2 == 0B) goto <D.5566>; else goto <D.5567>;
  <D.5566>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.5565 = 0;
  return D.5565;
  <D.5567>:
  goto <D.4943>;
  <D.4942>:
  {
    char c1;
    char c2;

    sp1.63 = sp1;
    sp1 = sp1.63 + 1;
    D.5569 = *sp1.63;
    D.5570 = (int) D.5569;
    c1 = monoeg_g_ascii_tolower (D.5570);
    sp2.64 = sp2;
    sp2 = sp2.64 + 1;
    D.5572 = *sp2.64;
    D.5573 = (int) D.5572;
    c2 = monoeg_g_ascii_tolower (D.5573);
    if (c1 != c2) goto <D.5574>; else goto <D.5575>;
    <D.5574>:
    D.5576 = (int) c1;
    D.5577 = (int) c2;
    D.5565 = D.5576 - D.5577;
    return D.5565;
    <D.5575>:
  }
  <D.4943>:
  D.5578 = *sp1;
  if (D.5578 != 0) goto <D.4942>; else goto <D.4944>;
  <D.4944>:
  D.5578 = *sp1;
  D.5579 = (int) D.5578;
  D.5580 = *sp2;
  D.5581 = (int) D.5580;
  D.5565 = D.5579 - D.5581;
  return D.5565;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.5585;
  _Bool iftmp.65;
  char D.5591;
  int D.5592;
  int D.5593;
  void * D.5596;
  char * D.5597;
  gchar * ptr;

  if (string == 0B) goto <D.5583>; else goto <D.5584>;
  <D.5583>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.5585 = 0B;
  return D.5585;
  <D.5584>:
  if (delimiters == 0B) goto <D.5586>; else goto <D.5587>;
  <D.5586>:
  delimiters = "_-|> <.";
  <D.5587>:
  ptr = string;
  goto <D.4952>;
  <D.4951>:
  D.5591 = *ptr;
  D.5592 = (int) D.5591;
  D.5593 = __builtin_constant_p (D.5592);
  if (D.5593 != 0) goto <D.5594>; else goto <D.5589>;
  <D.5594>:
  D.5591 = *ptr;
  if (D.5591 == 0) goto <D.5595>; else goto <D.5589>;
  <D.5595>:
  D.5591 = *ptr;
  D.5592 = (int) D.5591;
  D.5596 = __rawmemchr (delimiters, D.5592);
  iftmp.65 = D.5596 != 0B;
  goto <D.5590>;
  <D.5589>:
  D.5591 = *ptr;
  D.5592 = (int) D.5591;
  D.5597 = __builtin_strchr (delimiters, D.5592);
  iftmp.65 = D.5597 != 0B;
  <D.5590>:
  if (iftmp.65 != 0) goto <D.5598>; else goto <D.5599>;
  <D.5598>:
  *ptr = new_delimiter;
  <D.5599>:
  ptr = ptr + 1;
  <D.4952>:
  D.5591 = *ptr;
  if (D.5591 != 0) goto <D.4951>; else goto <D.4953>;
  <D.4953>:
  D.5585 = string;
  return D.5585;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.5603;
  const gchar * s.66;
  gchar * d.67;
  unsigned int D.5612;
  const gchar * s.68;
  char D.5614;
  int s.69;
  int src.70;
  int D.5617;
  int D.5618;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.5601>; else goto <D.5602>;
  <D.5601>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.5603 = 0;
  return D.5603;
  <D.5602>:
  if (dest == 0B) goto <D.5604>; else goto <D.5605>;
  <D.5604>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.5603 = 0;
  return D.5603;
  <D.5605>:
  len = dest_size;
  if (len == 0) goto <D.5606>; else goto <D.5607>;
  <D.5606>:
  D.5603 = 0;
  return D.5603;
  <D.5607>:
  s = src;
  d = dest;
  goto <D.4964>;
  <D.4963>:
  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.5610>; else goto <D.5611>;
  <D.5610>:
  D.5612 = dest_size - len;
  D.5603 = D.5612 + 4294967295;
  return D.5603;
  <D.5611>:
  <D.4964>:
  len = len + 4294967295;
  if (len != 0) goto <D.4963>; else goto <D.4965>;
  <D.4965>:
  *d = 0;
  goto <D.4967>;
  <D.4966>:
  <D.4967>:
  s.68 = s;
  s = s.68 + 1;
  D.5614 = *s.68;
  if (D.5614 != 0) goto <D.4966>; else goto <D.4968>;
  <D.4968>:
  s.69 = (int) s;
  src.70 = (int) src;
  D.5617 = s.69 - src.70;
  D.5618 = D.5617 + -1;
  D.5603 = (gsize) D.5618;
  return D.5603;
}


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

  if (dest == 0B) goto <D.5620>; else goto <D.5621>;
  <D.5620>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.5622 = dest;
  return D.5622;
  <D.5621>:
  if (src == 0B) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.5622 = dest;
  return D.5622;
  <D.5624>:
  D.5622 = stpcpy (dest, src);
  return D.5622;
}


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

  D.5627 = __builtin_object_size (__dest, 1);
  D.5626 = __builtin___stpcpy_chk (__dest, __src, D.5627);
  return D.5626;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.5631;
  char D.5634;
  int D.5635;
  unsigned int D.5636;
  unsigned int D.5637;
  unsigned int D.5638;
  int D.5639;
  gchar * res_ptr.71;
  gchar * res_ptr.72;
  gchar * res_ptr.73;
  gchar * res_ptr.74;
  unsigned char c.75;
  unsigned char D.5651;
  unsigned char D.5652;
  char D.5653;
  gchar * res_ptr.76;
  signed char D.5655;
  unsigned char D.5656;
  unsigned char D.5657;
  unsigned char D.5658;
  char D.5659;
  gchar * res_ptr.77;
  unsigned char D.5661;
  unsigned char D.5662;
  char D.5663;
  gchar escaped[256];
  const gchar * ptr;
  gchar c;
  gchar op;
  gchar * result;
  gchar * res_ptr;

  try
    {
      if (source == 0B) goto <D.5629>; else goto <D.5630>;
      <D.5629>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.5631 = 0B;
      return D.5631;
      <D.5630>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.5632>; else goto <D.5633>;
      <D.5632>:
      ptr = exceptions;
      goto <D.4985>;
      <D.4984>:
      D.5634 = *ptr;
      D.5635 = (int) D.5634;
      escaped[D.5635] = 0;
      ptr = ptr + 1;
      <D.4985>:
      D.5634 = *ptr;
      if (D.5634 != 0) goto <D.4984>; else goto <D.4986>;
      <D.4986>:
      <D.5633>:
      D.5636 = strlen (source);
      D.5637 = D.5636 * 4;
      D.5638 = D.5637 + 1;
      result = monoeg_malloc (D.5638);
      res_ptr = result;
      ptr = source;
      goto <D.4988>;
      <D.4987>:
      c = *ptr;
      D.5639 = (int) c;
      op = escaped[D.5639];
      if (op == 0) goto <D.5640>; else goto <D.5641>;
      <D.5640>:
      res_ptr.71 = res_ptr;
      res_ptr = res_ptr.71 + 1;
      *res_ptr.71 = c;
      goto <D.5643>;
      <D.5641>:
      res_ptr.72 = res_ptr;
      res_ptr = res_ptr.72 + 1;
      *res_ptr.72 = 92;
      if (op != 1) goto <D.5645>; else goto <D.5646>;
      <D.5645>:
      res_ptr.73 = res_ptr;
      res_ptr = res_ptr.73 + 1;
      *res_ptr.73 = op;
      goto <D.5648>;
      <D.5646>:
      res_ptr.74 = res_ptr;
      res_ptr = res_ptr.74 + 1;
      c.75 = (unsigned char) c;
      D.5651 = c.75 >> 6;
      D.5652 = D.5651 + 48;
      D.5653 = (char) D.5652;
      *res_ptr.74 = D.5653;
      res_ptr.76 = res_ptr;
      res_ptr = res_ptr.76 + 1;
      D.5655 = c >> 3;
      D.5656 = (unsigned char) D.5655;
      D.5657 = D.5656 & 7;
      D.5658 = D.5657 + 48;
      D.5659 = (char) D.5658;
      *res_ptr.76 = D.5659;
      res_ptr.77 = res_ptr;
      res_ptr = res_ptr.77 + 1;
      c.75 = (unsigned char) c;
      D.5661 = c.75 & 7;
      D.5662 = D.5661 + 48;
      D.5663 = (char) D.5662;
      *res_ptr.77 = D.5663;
      <D.5648>:
      <D.5643>:
      ptr = ptr + 1;
      <D.4988>:
      D.5634 = *ptr;
      if (D.5634 != 0) goto <D.4987>; else goto <D.4989>;
      <D.4989>:
      *res_ptr = 0;
      D.5631 = result;
      return D.5631;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


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

  D.5667 = __builtin_object_size (__dest, 0);
  D.5666 = __builtin___memcpy_chk (__dest, __src, __len, D.5667);
  return D.5666;
}


monoeg_g_ascii_xdigit_value (gchar c)
{
  gint D.5669;
  gint iftmp.78;
  const short unsigned int * * D.5671;
  const short unsigned int * D.5672;
  unsigned int D.5673;
  unsigned int D.5674;
  const short unsigned int * D.5675;
  short unsigned int D.5676;
  int D.5677;
  int D.5678;
  gint iftmp.79;
  unsigned char c.80;
  unsigned char D.5683;
  int D.5686;
  gint iftmp.81;
  unsigned char D.5689;

  D.5671 = __ctype_b_loc ();
  D.5672 = *D.5671;
  D.5673 = (unsigned int) c;
  D.5674 = D.5673 * 2;
  D.5675 = D.5672 + D.5674;
  D.5676 = *D.5675;
  D.5677 = (int) D.5676;
  D.5678 = D.5677 & 4096;
  if (D.5678 != 0) goto <D.5679>; else goto <D.5680>;
  <D.5679>:
  c.80 = (unsigned char) c;
  D.5683 = c.80 + 208;
  if (D.5683 <= 9) goto <D.5684>; else goto <D.5685>;
  <D.5684>:
  D.5686 = (int) c;
  iftmp.79 = D.5686 + -48;
  goto <D.5687>;
  <D.5685>:
  c.80 = (unsigned char) c;
  D.5689 = c.80 + 159;
  if (D.5689 <= 5) goto <D.5690>; else goto <D.5691>;
  <D.5690>:
  D.5686 = (int) c;
  iftmp.81 = D.5686 + -87;
  goto <D.5692>;
  <D.5691>:
  D.5686 = (int) c;
  iftmp.81 = D.5686 + -55;
  <D.5692>:
  iftmp.79 = iftmp.81;
  <D.5687>:
  iftmp.78 = iftmp.79;
  goto <D.5693>;
  <D.5680>:
  iftmp.78 = -1;
  <D.5693>:
  D.5669 = iftmp.78;
  return D.5669;
}


monoeg_g_strnfill (gsize length, gchar fill_char)
{
  unsigned int D.5695;
  int D.5696;
  gchar * D.5697;
  gchar * D.5698;
  gchar * ret;

  D.5695 = length + 1;
  ret = monoeg_malloc (D.5695);
  D.5696 = (int) fill_char;
  memset (ret, D.5696, length);
  D.5697 = ret + length;
  *D.5697 = 0;
  D.5698 = ret;
  return D.5698;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5702;
  int D.5707;
  void * D.5709;
  unsigned int D.5710;

  D.5702 = __builtin_constant_p (__len);
  if (D.5702 != 0) goto <D.5703>; else goto <D.5704>;
  <D.5703>:
  if (__len == 0) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  D.5707 = __builtin_constant_p (__ch);
  if (D.5707 == 0) goto <D.5700>; else goto <D.5708>;
  <D.5708>:
  if (__ch != 0) goto <D.5700>; else goto <D.5701>;
  <D.5700>:
  __warn_memset_zero_len ();
  D.5709 = __dest;
  return D.5709;
  <D.5701>:
  <D.5706>:
  <D.5704>:
  D.5710 = __builtin_object_size (__dest, 0);
  D.5709 = __builtin___memset_chk (__dest, __ch, __len, D.5710);
  return D.5709;
}