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

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


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

  orig = str_array;
  if (str_array == 0B) goto <D.5434>; else goto <D.5435>;
  <D.5434>:
  return;
  <D.5435>:
  goto <D.5036>;
  <D.5035>:
  D.5436 = *str_array;
  monoeg_g_free (D.5436);
  str_array = str_array + 8;
  <D.5036>:
  D.5436 = *str_array;
  if (D.5436 != 0B) goto <D.5035>; else goto <D.5037>;
  <D.5037>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.5440;
  unsigned int D.5441;
  long unsigned int D.5442;
  long unsigned int D.5443;
  long unsigned int D.5444;
  long unsigned int D.5445;
  gchar * * D.5446;
  gchar * * D.5447;
  gchar * D.5448;
  gchar * D.5449;
  long unsigned int D.5450;
  long unsigned int D.5451;
  gchar * * D.5452;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.5438>; else goto <D.5439>;
  <D.5438>:
  D.5440 = 0B;
  return D.5440;
  <D.5439>:
  length = monoeg_g_strv_length (str_array);
  D.5441 = length + 1;
  D.5442 = (long unsigned int) D.5441;
  D.5443 = D.5442 * 8;
  ret = monoeg_malloc0 (D.5443);
  i = 0;
  goto <D.5045>;
  <D.5044>:
  D.5444 = (long unsigned int) i;
  D.5445 = D.5444 * 8;
  D.5446 = ret + D.5445;
  D.5444 = (long unsigned int) i;
  D.5445 = D.5444 * 8;
  D.5447 = str_array + D.5445;
  D.5448 = *D.5447;
  D.5449 = monoeg_strdup (D.5448);
  *D.5446 = D.5449;
  i = i + 1;
  <D.5045>:
  D.5444 = (long unsigned int) i;
  D.5445 = D.5444 * 8;
  D.5447 = str_array + D.5445;
  D.5448 = *D.5447;
  if (D.5448 != 0B) goto <D.5044>; else goto <D.5046>;
  <D.5046>:
  D.5450 = (long unsigned int) length;
  D.5451 = D.5450 * 8;
  D.5452 = ret + D.5451;
  *D.5452 = 0B;
  D.5440 = ret;
  return D.5440;
}


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

  if (str != 0B) goto <D.5454>; else goto <D.5455>;
  <D.5454>:
  D.5456 = __strdup (str);
  return D.5456;
  <D.5455>:
  D.5456 = 0B;
  return D.5456;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.5460;
  long unsigned int D.5461;
  long unsigned int D.5462;
  gchar * * D.5463;
  gchar * D.5464;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.5458>; else goto <D.5459>;
  <D.5458>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.5460 = 0;
  return D.5460;
  <D.5459>:
  length = 0;
  goto <D.5052>;
  <D.5051>:
  length = length + 1;
  <D.5052>:
  D.5461 = (long unsigned int) length;
  D.5462 = D.5461 * 8;
  D.5463 = str_array + D.5462;
  D.5464 = *D.5463;
  if (D.5464 != 0B) goto <D.5051>; else goto <D.5053>;
  <D.5053>:
  D.5460 = (guint) length;
  return D.5460;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.5468;
  int iftmp.0;
  sizetype D.5475;
  const gchar * D.5476;
  int D.5477;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.5466>; else goto <D.5467>;
  <D.5466>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.5468 = 0;
  return D.5468;
  <D.5467>:
  if (suffix == 0B) goto <D.5469>; else goto <D.5470>;
  <D.5469>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.5468 = 0;
  return D.5468;
  <D.5470>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.5474>; else goto <D.5472>;
  <D.5474>:
  D.5475 = str_length - suffix_length;
  D.5476 = str + D.5475;
  D.5477 = strncmp (D.5476, suffix, suffix_length);
  if (D.5477 == 0) goto <D.5478>; else goto <D.5472>;
  <D.5478>:
  iftmp.0 = 1;
  goto <D.5473>;
  <D.5472>:
  iftmp.0 = 0;
  <D.5473>:
  D.5468 = iftmp.0;
  return D.5468;
}


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

  if (str == 0B) goto <D.5480>; else goto <D.5481>;
  <D.5480>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.5482 = 0;
  return D.5482;
  <D.5481>:
  if (prefix == 0B) goto <D.5483>; else goto <D.5484>;
  <D.5483>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.5482 = 0;
  return D.5482;
  <D.5484>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.5488>; else goto <D.5486>;
  <D.5488>:
  D.5489 = strncmp (str, prefix, prefix_length);
  if (D.5489 == 0) goto <D.5490>; else goto <D.5486>;
  <D.5490>:
  iftmp.1 = 1;
  goto <D.5487>;
  <D.5486>:
  iftmp.1 = 0;
  <D.5487>:
  D.5482 = iftmp.1;
  return D.5482;
}


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

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
vasprintf (char * * restrict __ptr, const char * restrict __fmt, struct  * __ap)
{
  int D.5497;

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


monoeg_g_strdup_printf (const gchar * format)
{
  gchar * D.5501;
  gchar * ret;
  struct  args[1];
  int n;

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


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

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


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.5508;
  long unsigned int D.5509;
  long unsigned int D.5510;
  long unsigned int D.5511;
  char * D.5514;
  struct  args[1];
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.5506>; else goto <D.5507>;
      <D.5506>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.5508 = 0B;
      return D.5508;
      <D.5507>:
      D.5509 = strlen (first);
      total = D.5509 + total;
      __builtin_va_start (&args, 0);
      s = VA_ARG (&args, 0B, 0B);
      goto <D.5107>;
      <D.5106>:
      D.5510 = strlen (s);
      total = D.5510 + total;
      s = VA_ARG (&args, 0B, 0B);
      <D.5107>:
      if (s != 0B) goto <D.5106>; else goto <D.5108>;
      <D.5108>:
      __builtin_va_end (&args);
      D.5511 = total + 1;
      ret = monoeg_malloc (D.5511);
      if (ret == 0B) goto <D.5512>; else goto <D.5513>;
      <D.5512>:
      D.5508 = 0B;
      return D.5508;
      <D.5513>:
      D.5514 = ret + total;
      *D.5514 = 0;
      strcpy (ret, first);
      __builtin_va_start (&args, 0);
      s = VA_ARG (&args, 0B, 0B);
      goto <D.5110>;
      <D.5109>:
      strcat (ret, s);
      s = VA_ARG (&args, 0B, 0B);
      <D.5110>:
      if (s != 0B) goto <D.5109>; else goto <D.5111>;
      <D.5111>:
      __builtin_va_end (&args);
      D.5508 = ret;
      return D.5508;
    }
  finally
    {
      args = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.5517;
  long unsigned int D.5518;

  D.5518 = __builtin_object_size (__dest, 1);
  D.5517 = __builtin___strcpy_chk (__dest, __src, D.5518);
  return D.5517;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.5520;
  long unsigned int D.5521;

  D.5521 = __builtin_object_size (__dest, 1);
  D.5520 = __builtin___strcat_chk (__dest, __src, D.5521);
  return D.5520;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5525;
  char D.5528;
  long unsigned int D.5531;
  int D.5532;
  void * vector.2;
  gchar * * vector.3;
  gchar * D.5537;
  long unsigned int D.5538;
  long unsigned int D.5540;
  int D.5541;
  long unsigned int D.5544;
  char D.5546;
  long unsigned int D.5548;
  int D.5549;
  long int string.4;
  long int c.5;
  long int D.5554;
  int D.5165;
  long unsigned int D.5557;
  int D.5177;
  gchar * D.5565;
  gchar * D.5567;
  void * vector.6;
  long unsigned int D.5574;
  long unsigned int D.5575;
  sizetype D.5576;
  gchar * * D.5577;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5523>; else goto <D.5524>;
      <D.5523>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.5525 = 0B;
      return D.5525;
      <D.5524>:
      if (delimiter == 0B) goto <D.5526>; else goto <D.5527>;
      <D.5526>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.5525 = 0B;
      return D.5525;
      <D.5527>:
      D.5528 = *delimiter;
      if (D.5528 == 0) goto <D.5529>; else goto <D.5530>;
      <D.5529>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.5525 = 0B;
      return D.5525;
      <D.5530>:
      D.5531 = strlen (delimiter);
      D.5532 = strncmp (string, delimiter, D.5531);
      if (D.5532 == 0) goto <D.5533>; else goto <D.5534>;
      <D.5533>:
      vector.2 = monoeg_malloc (16);
      vector = vector.2;
      vector.3 = vector;
      D.5537 = monoeg_strdup ("");
      *vector.3 = D.5537;
      size = size + 1;
      D.5538 = strlen (delimiter);
      string = string + D.5538;
      goto <D.5539>;
      <D.5534>:
      vector = 0B;
      <D.5539>:
      goto <D.5167>;
      <D.5166>:
      c = string;
      D.5540 = strlen (delimiter);
      D.5541 = strncmp (string, delimiter, D.5540);
      if (D.5541 == 0) goto <D.5542>; else goto <D.5543>;
      <D.5542>:
      token = monoeg_strdup ("");
      D.5544 = strlen (delimiter);
      string = string + D.5544;
      goto <D.5545>;
      <D.5543>:
      goto <D.5154>;
      <D.5153>:
      string = string + 1;
      <D.5154>:
      D.5546 = *string;
      if (D.5546 != 0) goto <D.5547>; else goto <D.5155>;
      <D.5547>:
      D.5548 = strlen (delimiter);
      D.5549 = strncmp (string, delimiter, D.5548);
      if (D.5549 != 0) goto <D.5153>; else goto <D.5155>;
      <D.5155>:
      D.5546 = *string;
      if (D.5546 != 0) goto <D.5550>; else goto <D.5551>;
      <D.5550>:
      {
        gsize toklen;

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

          D.5165 = __builtin_strcmp (string, delimiter);
        }
        if (D.5165 != 0) goto <D.5555>; else goto <D.5556>;
        <D.5555>:
        D.5557 = strlen (delimiter);
        string = string + D.5557;
        <D.5556>:
      }
      goto <D.5558>;
      <D.5551>:
      token = monoeg_strdup (c);
      <D.5558>:
      <D.5545>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.5167>:
      D.5546 = *string;
      if (D.5546 != 0) goto <D.5559>; else goto <D.5168>;
      <D.5559>:
      if (max_tokens <= 0) goto <D.5166>; else goto <D.5560>;
      <D.5560>:
      if (size < max_tokens) goto <D.5166>; else goto <D.5168>;
      <D.5168>:
      D.5546 = *string;
      if (D.5546 != 0) goto <D.5561>; else goto <D.5562>;
      <D.5561>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.5177 = __builtin_strcmp (string, delimiter);
      }
      if (D.5177 == 0) goto <D.5563>; else goto <D.5564>;
      <D.5563>:
      D.5565 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5565);
      goto <D.5566>;
      <D.5564>:
      D.5567 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5567);
      <D.5566>:
      size = size + 1;
      <D.5562>:
      vector.3 = vector;
      if (vector.3 == 0B) goto <D.5568>; else goto <D.5569>;
      <D.5568>:
      vector.6 = monoeg_malloc (16);
      vector = vector.6;
      vector.3 = vector;
      *vector.3 = 0B;
      goto <D.5571>;
      <D.5569>:
      if (size > 0) goto <D.5572>; else goto <D.5573>;
      <D.5572>:
      vector.3 = vector;
      D.5574 = (long unsigned int) size;
      D.5575 = D.5574 * 8;
      D.5576 = D.5575 + 18446744073709551608;
      D.5577 = vector.3 + D.5576;
      *D.5577 = 0B;
      <D.5573>:
      <D.5571>:
      D.5525 = vector;
      return D.5525;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.7;
  gchar * * D.5581;
  int D.5585;
  long unsigned int D.5586;
  long unsigned int D.5587;
  long unsigned int D.5588;
  long unsigned int D.5589;
  sizetype D.5590;
  gchar * * D.5591;

  D.5581 = *vector;
  if (D.5581 == 0B) goto <D.5582>; else goto <D.5583>;
  <D.5582>:
  iftmp.7 = monoeg_malloc (16);
  goto <D.5584>;
  <D.5583>:
  D.5581 = *vector;
  D.5585 = size + 1;
  D.5586 = (long unsigned int) D.5585;
  D.5587 = D.5586 * 8;
  iftmp.7 = monoeg_realloc (D.5581, D.5587);
  <D.5584>:
  *vector = iftmp.7;
  D.5581 = *vector;
  D.5588 = (long unsigned int) size;
  D.5589 = D.5588 * 8;
  D.5590 = D.5589 + 18446744073709551608;
  D.5591 = D.5581 + D.5590;
  *D.5591 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5594;
  char D.5597;
  char D.5600;
  int D.5601;
  void * vector.8;
  gchar * * vector.9;
  gchar * D.5606;
  int D.5608;
  long int string.10;
  long int c.11;
  long int D.5613;
  gchar * D.5625;
  char D.5626;
  gchar * D.5629;
  gchar * D.5631;
  void * vector.12;
  long unsigned int D.5638;
  long unsigned int D.5639;
  sizetype D.5640;
  gchar * * D.5641;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5592>; else goto <D.5593>;
      <D.5592>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.5594 = 0B;
      return D.5594;
      <D.5593>:
      if (delimiter == 0B) goto <D.5595>; else goto <D.5596>;
      <D.5595>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.5594 = 0B;
      return D.5594;
      <D.5596>:
      D.5597 = *delimiter;
      if (D.5597 == 0) goto <D.5598>; else goto <D.5599>;
      <D.5598>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.5594 = 0B;
      return D.5594;
      <D.5599>:
      D.5600 = *string;
      D.5601 = charcmp (D.5600, delimiter);
      if (D.5601 != 0) goto <D.5602>; else goto <D.5603>;
      <D.5602>:
      vector.8 = monoeg_malloc (16);
      vector = vector.8;
      vector.9 = vector;
      D.5606 = monoeg_strdup ("");
      *vector.9 = D.5606;
      size = size + 1;
      string = string + 1;
      goto <D.5607>;
      <D.5603>:
      vector = 0B;
      <D.5607>:
      c = string;
      goto <D.5196>;
      <D.5195>:
      D.5600 = *string;
      D.5608 = charcmp (D.5600, delimiter);
      if (D.5608 != 0) goto <D.5609>; else goto <D.5610>;
      <D.5609>:
      {
        gsize toklen;

        string.10 = (long int) string;
        c.11 = (long int) c;
        D.5613 = string.10 - c.11;
        toklen = (gsize) D.5613;
        if (toklen == 0) goto <D.5614>; else goto <D.5615>;
        <D.5614>:
        token = monoeg_strdup ("");
        goto <D.5616>;
        <D.5615>:
        token = monoeg_g_strndup (c, toklen);
        <D.5616>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.5610>:
      string = string + 1;
      <D.5196>:
      D.5600 = *string;
      if (D.5600 != 0) goto <D.5617>; else goto <D.5197>;
      <D.5617>:
      if (max_tokens <= 0) goto <D.5195>; else goto <D.5618>;
      <D.5618>:
      if (size < max_tokens) goto <D.5195>; else goto <D.5197>;
      <D.5197>:
      if (max_tokens > 0) goto <D.5621>; else goto <D.5619>;
      <D.5621>:
      if (size >= max_tokens) goto <D.5622>; else goto <D.5619>;
      <D.5622>:
      D.5600 = *string;
      if (D.5600 != 0) goto <D.5623>; else goto <D.5624>;
      <D.5623>:
      D.5625 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5625);
      size = size + 1;
      <D.5624>:
      goto <D.5620>;
      <D.5619>:
      D.5626 = *c;
      if (D.5626 != 0) goto <D.5627>; else goto <D.5628>;
      <D.5627>:
      D.5629 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.5629);
      size = size + 1;
      goto <D.5630>;
      <D.5628>:
      D.5631 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5631);
      size = size + 1;
      <D.5630>:
      <D.5620>:
      vector.9 = vector;
      if (vector.9 == 0B) goto <D.5632>; else goto <D.5633>;
      <D.5632>:
      vector.12 = monoeg_malloc (16);
      vector = vector.12;
      vector.9 = vector;
      *vector.9 = 0B;
      goto <D.5635>;
      <D.5633>:
      if (size > 0) goto <D.5636>; else goto <D.5637>;
      <D.5636>:
      vector.9 = vector;
      D.5638 = (long unsigned int) size;
      D.5639 = D.5638 * 8;
      D.5640 = D.5639 + 18446744073709551608;
      D.5641 = vector.9 + D.5640;
      *D.5641 = 0B;
      <D.5637>:
      <D.5635>:
      D.5594 = vector;
      return D.5594;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.5644;
  gboolean D.5647;

  goto <D.5183>;
  <D.5182>:
  D.5644 = *compare;
  if (D.5644 == testchar) goto <D.5645>; else goto <D.5646>;
  <D.5645>:
  D.5647 = 1;
  return D.5647;
  <D.5646>:
  compare = compare + 1;
  <D.5183>:
  D.5644 = *compare;
  if (D.5644 != 0) goto <D.5182>; else goto <D.5184>;
  <D.5184>:
  D.5647 = 0;
  return D.5647;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.5651;
  char D.5652;
  long unsigned int D.5655;
  gchar * D.5656;
  gchar * D.5657;
  char D.5658;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.5649>; else goto <D.5650>;
  <D.5649>:
  D.5651 = 0B;
  return D.5651;
  <D.5650>:
  D.5652 = *str;
  if (D.5652 == 0) goto <D.5653>; else goto <D.5654>;
  <D.5653>:
  D.5651 = str;
  return D.5651;
  <D.5654>:
  i = 0;
  D.5655 = strlen (str);
  j = D.5655 + 18446744073709551615;
  goto <D.5205>;
  <D.5204>:
  D.5656 = str + i;
  c = *D.5656;
  D.5656 = str + i;
  D.5657 = str + j;
  D.5658 = *D.5657;
  *D.5656 = D.5658;
  D.5657 = str + j;
  *D.5657 = c;
  i = i + 1;
  j = j + 18446744073709551615;
  <D.5205>:
  if (i < j) goto <D.5204>; else goto <D.5206>;
  <D.5206>:
  D.5651 = str;
  return D.5651;
}


monoeg_g_strjoin (const gchar * separator)
{
  long unsigned int D.5663;
  gchar * D.5666;
  long unsigned int D.5671;
  struct  args[1];
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.5660>; else goto <D.5661>;
      <D.5660>:
      slen = strlen (separator);
      goto <D.5662>;
      <D.5661>:
      slen = 0;
      <D.5662>:
      len = 0;
      __builtin_va_start (&args, 0);
      s = VA_ARG (&args, 0B, 0B);
      goto <D.5217>;
      <D.5216>:
      D.5663 = strlen (s);
      len = D.5663 + len;
      len = len + slen;
      s = VA_ARG (&args, 0B, 0B);
      <D.5217>:
      if (s != 0B) goto <D.5216>; else goto <D.5218>;
      <D.5218>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.5664>; else goto <D.5665>;
      <D.5664>:
      D.5666 = monoeg_strdup ("");
      return D.5666;
      <D.5665>:
      if (slen != 0) goto <D.5667>; else goto <D.5668>;
      <D.5667>:
      if (len != 0) goto <D.5669>; else goto <D.5670>;
      <D.5669>:
      len = len - slen;
      <D.5670>:
      <D.5668>:
      D.5671 = len + 1;
      res = monoeg_malloc (D.5671);
      __builtin_va_start (&args, 0);
      s = VA_ARG (&args, 0B, 0B);
      r = monoeg_g_stpcpy (res, s);
      s = VA_ARG (&args, 0B, 0B);
      goto <D.5220>;
      <D.5219>:
      if (separator != 0B) goto <D.5672>; else goto <D.5673>;
      <D.5672>:
      r = monoeg_g_stpcpy (r, separator);
      <D.5673>:
      r = monoeg_g_stpcpy (r, s);
      s = VA_ARG (&args, 0B, 0B);
      <D.5220>:
      if (s != 0B) goto <D.5219>; else goto <D.5221>;
      <D.5221>:
      __builtin_va_end (&args);
      D.5666 = res;
      return D.5666;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  long unsigned int D.5679;
  gchar * * D.5680;
  gchar * D.5681;
  long unsigned int D.5682;
  gchar * D.5685;
  long unsigned int D.5690;
  gchar * D.5691;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.5676>; else goto <D.5677>;
  <D.5676>:
  slen = strlen (separator);
  goto <D.5678>;
  <D.5677>:
  slen = 0;
  <D.5678>:
  len = 0;
  i = 0;
  goto <D.5232>;
  <D.5231>:
  D.5679 = i * 8;
  D.5680 = str_array + D.5679;
  D.5681 = *D.5680;
  D.5682 = strlen (D.5681);
  len = D.5682 + len;
  len = len + slen;
  i = i + 1;
  <D.5232>:
  D.5679 = i * 8;
  D.5680 = str_array + D.5679;
  D.5681 = *D.5680;
  if (D.5681 != 0B) goto <D.5231>; else goto <D.5233>;
  <D.5233>:
  if (len == 0) goto <D.5683>; else goto <D.5684>;
  <D.5683>:
  D.5685 = monoeg_strdup ("");
  return D.5685;
  <D.5684>:
  if (slen != 0) goto <D.5686>; else goto <D.5687>;
  <D.5686>:
  if (len != 0) goto <D.5688>; else goto <D.5689>;
  <D.5688>:
  len = len - slen;
  <D.5689>:
  <D.5687>:
  D.5690 = len + 1;
  res = monoeg_malloc (D.5690);
  D.5691 = *str_array;
  r = monoeg_g_stpcpy (res, D.5691);
  i = 1;
  goto <D.5235>;
  <D.5234>:
  if (separator != 0B) goto <D.5692>; else goto <D.5693>;
  <D.5692>:
  r = monoeg_g_stpcpy (r, separator);
  <D.5693>:
  D.5679 = i * 8;
  D.5680 = str_array + D.5679;
  D.5681 = *D.5680;
  r = monoeg_g_stpcpy (r, D.5681);
  i = i + 1;
  <D.5235>:
  D.5679 = i * 8;
  D.5680 = str_array + D.5679;
  D.5681 = *D.5680;
  if (D.5681 != 0B) goto <D.5234>; else goto <D.5236>;
  <D.5236>:
  D.5685 = res;
  return D.5685;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.5697;
  char D.5698;
  const short unsigned int * * D.5700;
  const short unsigned int * D.5701;
  long unsigned int D.5702;
  long unsigned int D.5703;
  const short unsigned int * D.5704;
  short unsigned int D.5705;
  int D.5706;
  int D.5707;
  long unsigned int D.5710;
  long int tmp.13;
  long int str.14;
  long int D.5713;
  long unsigned int D.5714;
  long unsigned int D.5715;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  D.5697 = 0B;
  return D.5697;
  <D.5696>:
  tmp = str;
  goto <D.5243>;
  <D.5242>:
  tmp = tmp + 1;
  <D.5243>:
  D.5698 = *tmp;
  if (D.5698 != 0) goto <D.5699>; else goto <D.5244>;
  <D.5699>:
  D.5700 = __ctype_b_loc ();
  D.5701 = *D.5700;
  D.5698 = *tmp;
  D.5702 = (long unsigned int) D.5698;
  D.5703 = D.5702 * 2;
  D.5704 = D.5701 + D.5703;
  D.5705 = *D.5704;
  D.5706 = (int) D.5705;
  D.5707 = D.5706 & 32;
  if (D.5707 != 0) goto <D.5242>; else goto <D.5244>;
  <D.5244>:
  if (str != tmp) goto <D.5708>; else goto <D.5709>;
  <D.5708>:
  D.5710 = strlen (str);
  tmp.13 = (long int) tmp;
  str.14 = (long int) str;
  D.5713 = tmp.13 - str.14;
  D.5714 = (long unsigned int) D.5713;
  D.5715 = D.5710 - D.5714;
  len = D.5715 + 1;
  memmove (str, tmp, len);
  <D.5709>:
  D.5697 = str;
  return D.5697;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.5717;
  long unsigned int D.5718;

  D.5718 = __builtin_object_size (__dest, 0);
  D.5717 = __builtin___memmove_chk (__dest, __src, __len, D.5718);
  return D.5717;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.5722;
  long unsigned int D.5723;
  sizetype D.5724;
  char D.5725;
  const short unsigned int * * D.5727;
  const short unsigned int * D.5728;
  long unsigned int D.5729;
  long unsigned int D.5730;
  const short unsigned int * D.5731;
  short unsigned int D.5732;
  int D.5733;
  int D.5734;
  gchar * D.5735;
  gchar * tmp;

  if (str == 0B) goto <D.5720>; else goto <D.5721>;
  <D.5720>:
  D.5722 = 0B;
  return D.5722;
  <D.5721>:
  D.5723 = strlen (str);
  D.5724 = D.5723 + 18446744073709551615;
  tmp = str + D.5724;
  goto <D.5250>;
  <D.5249>:
  tmp = tmp + 18446744073709551615;
  <D.5250>:
  D.5725 = *tmp;
  if (D.5725 != 0) goto <D.5726>; else goto <D.5251>;
  <D.5726>:
  D.5727 = __ctype_b_loc ();
  D.5728 = *D.5727;
  D.5725 = *tmp;
  D.5729 = (long unsigned int) D.5725;
  D.5730 = D.5729 * 2;
  D.5731 = D.5728 + D.5730;
  D.5732 = *D.5731;
  D.5733 = (int) D.5732;
  D.5734 = D.5733 & 32;
  if (D.5734 != 0) goto <D.5249>; else goto <D.5251>;
  <D.5251>:
  D.5735 = tmp + 1;
  *D.5735 = 0;
  D.5722 = str;
  return D.5722;
}


monoeg_g_printf (const gchar * format)
{
  gint D.5737;
  struct  args[1];
  gint ret;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
vprintf (const char * restrict __fmt, struct  * __ap)
{
  int D.5740;
  struct _IO_FILE * stdout.15;

  stdout.15 = stdout;
  D.5740 = __vfprintf_chk (stdout.15, 1, __fmt, __ap);
  return D.5740;
}


monoeg_g_fprintf (struct FILE * file, const gchar * format)
{
  gint D.5743;
  struct  args[1];
  gint ret;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
vfprintf (struct FILE * restrict __stream, const char * restrict __fmt, struct  * __ap)
{
  int D.5746;

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


monoeg_g_sprintf (gchar * string, const gchar * format)
{
  gint D.5748;
  struct  args[1];
  gint ret;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
vsprintf (char * restrict __s, const char * restrict __fmt, struct  * __ap)
{
  int D.5751;
  long unsigned int D.5752;

  D.5752 = __builtin_object_size (__s, 1);
  D.5751 = __builtin___vsprintf_chk (__s, 1, D.5752, __fmt, __ap);
  return D.5751;
}


monoeg_g_snprintf (gchar * string, gulong n, const gchar * format)
{
  gint D.5754;
  struct  args[1];
  gint ret;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, struct  * __ap)
{
  int D.5757;
  long unsigned int D.5758;

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


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.5762;
  int D.5765;
  struct GError * D.5770;
  long unsigned int D.5771;
  char D.5772;
  int D.5773;
  long unsigned int D.5777;
  int D.5778;
  char * rp.16;
  char * rp.17;
  unsigned char D.5783;
  int D.5784;
  char D.5785;
  char * rp.18;
  int D.5787;
  int D.5788;
  char D.5789;
  char * rp.19;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.5760>; else goto <D.5761>;
  <D.5760>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.5762 = 0B;
  return D.5762;
  <D.5761>:
  if (hostname != 0B) goto <D.5763>; else goto <D.5764>;
  <D.5763>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.5764>:
  D.5765 = monoeg_g_path_is_absolute (filename);
  if (D.5765 == 0) goto <D.5766>; else goto <D.5767>;
  <D.5766>:
  if (error != 0B) goto <D.5768>; else goto <D.5769>;
  <D.5768>:
  D.5770 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.5770;
  <D.5769>:
  D.5762 = 0B;
  return D.5762;
  <D.5767>:
  D.5771 = strlen (uriPrefix);
  n = D.5771 + 1;
  p = filename;
  goto <D.5291>;
  <D.5290>:
  D.5772 = *p;
  D.5773 = char_needs_encoding (D.5772);
  if (D.5773 != 0) goto <D.5774>; else goto <D.5775>;
  <D.5774>:
  n = n + 3;
  goto <D.5776>;
  <D.5775>:
  n = n + 1;
  <D.5776>:
  p = p + 1;
  <D.5291>:
  D.5772 = *p;
  if (D.5772 != 0) goto <D.5290>; else goto <D.5292>;
  <D.5292>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.5777 = strlen (ret);
  rp = ret + D.5777;
  goto <D.5294>;
  <D.5293>:
  D.5772 = *p;
  D.5778 = char_needs_encoding (D.5772);
  if (D.5778 != 0) goto <D.5779>; else goto <D.5780>;
  <D.5779>:
  rp.16 = rp;
  rp = rp.16 + 1;
  *rp.16 = 37;
  rp.17 = rp;
  rp = rp.17 + 1;
  D.5772 = *p;
  D.5783 = D.5772 >> 4;
  D.5784 = (int) D.5783;
  D.5785 = hx[D.5784];
  *rp.17 = D.5785;
  rp.18 = rp;
  rp = rp.18 + 1;
  D.5772 = *p;
  D.5787 = (int) D.5772;
  D.5788 = D.5787 & 15;
  D.5789 = hx[D.5788];
  *rp.18 = D.5789;
  goto <D.5790>;
  <D.5780>:
  rp.19 = rp;
  rp = rp.19 + 1;
  D.5772 = *p;
  *rp.19 = D.5772;
  <D.5790>:
  p = p + 1;
  <D.5294>:
  D.5772 = *p;
  if (D.5772 != 0) goto <D.5293>; else goto <D.5295>;
  <D.5295>:
  *rp = 0;
  D.5762 = ret;
  return D.5762;
}


char_needs_encoding (char c)
{
  signed char c.20;
  gboolean D.5796;
  char D.5799;
  char D.5801;
  char D.5803;

  c.20 = (signed char) c;
  if (c.20 < 0) goto <D.5794>; else goto <D.5795>;
  <D.5794>:
  D.5796 = 1;
  return D.5796;
  <D.5795>:
  D.5799 = c + 192;
  if (D.5799 <= 26) goto <D.5797>; else goto <D.5800>;
  <D.5800>:
  D.5801 = c + 159;
  if (D.5801 <= 25) goto <D.5797>; else goto <D.5802>;
  <D.5802>:
  D.5803 = c + 218;
  if (D.5803 <= 20) goto <D.5797>; else goto <D.5804>;
  <D.5804>:
  if (c == 33) goto <D.5797>; else goto <D.5805>;
  <D.5805>:
  if (c == 36) goto <D.5797>; else goto <D.5806>;
  <D.5806>:
  if (c == 95) goto <D.5797>; else goto <D.5807>;
  <D.5807>:
  if (c == 61) goto <D.5797>; else goto <D.5808>;
  <D.5808>:
  if (c == 126) goto <D.5797>; else goto <D.5798>;
  <D.5797>:
  D.5796 = 0;
  return D.5796;
  <D.5798>:
  D.5796 = 1;
  return D.5796;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.5812;
  int D.5815;
  struct GError * D.5820;
  char D.5821;
  const char * D.5826;
  char D.5827;
  const char * D.5829;
  char D.5830;
  const short unsigned int * * D.5832;
  const short unsigned int * D.5833;
  long unsigned int D.5834;
  long unsigned int D.5835;
  const short unsigned int * D.5836;
  short unsigned int D.5837;
  int D.5838;
  int D.5839;
  long unsigned int D.5841;
  long unsigned int D.5842;
  const short unsigned int * D.5843;
  short unsigned int D.5844;
  int D.5845;
  int D.5846;
  struct GError * D.5850;
  int D.5851;
  long unsigned int D.5852;
  sizetype D.5853;
  char * D.5854;
  char * r.21;
  int D.5858;
  int D.5859;
  signed char D.5860;
  int D.5861;
  signed char D.5862;
  signed char D.5863;
  char D.5864;
  char * r.22;
  const char * p;
  char * r;
  char * result;
  int flen;

  flen = 0;
  if (uri == 0B) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 629, "uri != NULL");
  D.5812 = 0B;
  return D.5812;
  <D.5811>:
  if (hostname != 0B) goto <D.5813>; else goto <D.5814>;
  <D.5813>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_from_uri: hostname not handled");
  <D.5814>:
  D.5815 = strncmp (uri, "file:///", 8);
  if (D.5815 != 0) goto <D.5816>; else goto <D.5817>;
  <D.5816>:
  if (error != 0B) goto <D.5818>; else goto <D.5819>;
  <D.5818>:
  D.5820 = monoeg_g_error_new (0B, 2, "URI does not start with the file: scheme");
  *error = D.5820;
  <D.5819>:
  D.5812 = 0B;
  return D.5812;
  <D.5817>:
  p = uri + 8;
  goto <D.5318>;
  <D.5317>:
  D.5821 = *p;
  if (D.5821 == 37) goto <D.5822>; else goto <D.5823>;
  <D.5822>:
  D.5826 = p + 1;
  D.5827 = *D.5826;
  if (D.5827 != 0) goto <D.5828>; else goto <D.5824>;
  <D.5828>:
  D.5829 = p + 2;
  D.5830 = *D.5829;
  if (D.5830 != 0) goto <D.5831>; else goto <D.5824>;
  <D.5831>:
  D.5832 = __ctype_b_loc ();
  D.5833 = *D.5832;
  D.5826 = p + 1;
  D.5827 = *D.5826;
  D.5834 = (long unsigned int) D.5827;
  D.5835 = D.5834 * 2;
  D.5836 = D.5833 + D.5835;
  D.5837 = *D.5836;
  D.5838 = (int) D.5837;
  D.5839 = D.5838 & 16;
  if (D.5839 != 0) goto <D.5840>; else goto <D.5824>;
  <D.5840>:
  D.5832 = __ctype_b_loc ();
  D.5833 = *D.5832;
  D.5829 = p + 2;
  D.5830 = *D.5829;
  D.5841 = (long unsigned int) D.5830;
  D.5842 = D.5841 * 2;
  D.5843 = D.5833 + D.5842;
  D.5844 = *D.5843;
  D.5845 = (int) D.5844;
  D.5846 = D.5845 & 16;
  if (D.5846 != 0) goto <D.5847>; else goto <D.5824>;
  <D.5847>:
  p = p + 2;
  goto <D.5825>;
  <D.5824>:
  if (error != 0B) goto <D.5848>; else goto <D.5849>;
  <D.5848>:
  D.5850 = monoeg_g_error_new (0B, 2, "URI contains an invalid escape sequence");
  *error = D.5850;
  <D.5849>:
  D.5812 = 0B;
  return D.5812;
  <D.5825>:
  <D.5823>:
  flen = flen + 1;
  p = p + 1;
  <D.5318>:
  D.5821 = *p;
  if (D.5821 != 0) goto <D.5317>; else goto <D.5319>;
  <D.5319>:
  flen = flen + 1;
  D.5851 = flen + 1;
  D.5852 = (long unsigned int) D.5851;
  result = monoeg_malloc (D.5852);
  D.5853 = (sizetype) flen;
  D.5854 = result + D.5853;
  *D.5854 = 0;
  *result = 47;
  r = result + 1;
  p = uri + 8;
  goto <D.5321>;
  <D.5320>:
  D.5821 = *p;
  if (D.5821 == 37) goto <D.5855>; else goto <D.5856>;
  <D.5855>:
  r.21 = r;
  r = r.21 + 1;
  D.5826 = p + 1;
  D.5827 = *D.5826;
  D.5858 = decode (D.5827);
  D.5859 = D.5858 << 4;
  D.5860 = (signed char) D.5859;
  D.5829 = p + 2;
  D.5830 = *D.5829;
  D.5861 = decode (D.5830);
  D.5862 = (signed char) D.5861;
  D.5863 = D.5860 | D.5862;
  D.5864 = (char) D.5863;
  *r.21 = D.5864;
  p = p + 2;
  goto <D.5865>;
  <D.5856>:
  r.22 = r;
  r = r.22 + 1;
  D.5821 = *p;
  *r.22 = D.5821;
  <D.5865>:
  flen = flen + 1;
  p = p + 1;
  <D.5321>:
  D.5821 = *p;
  if (D.5821 != 0) goto <D.5320>; else goto <D.5322>;
  <D.5322>:
  D.5812 = result;
  return D.5812;
}


decode (char p)
{
  char D.5868;
  int D.5871;
  int D.5872;
  char D.5873;
  char D.5876;

  D.5868 = p + 208;
  if (D.5868 <= 9) goto <D.5869>; else goto <D.5870>;
  <D.5869>:
  D.5872 = (int) p;
  D.5871 = D.5872 + -48;
  return D.5871;
  <D.5870>:
  D.5873 = p + 191;
  if (D.5873 <= 5) goto <D.5874>; else goto <D.5875>;
  <D.5874>:
  D.5872 = (int) p;
  D.5871 = D.5872 + -65;
  return D.5871;
  <D.5875>:
  D.5876 = p + 159;
  if (D.5876 <= 5) goto <D.5877>; else goto <D.5878>;
  <D.5877>:
  D.5872 = (int) p;
  D.5871 = D.5872 + -97;
  return D.5871;
  <D.5878>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gstr.c", 618);
  D.5871 = 0;
  return D.5871;
}


monoeg_g_strdown (gchar * string)
{
  int D.5328;
  char D.5884;
  int D.5885;
  int D.5886;
  const int iftmp.23;
  unsigned int __c.24;
  unsigned int D.5891;
  const __int32_t * * D.5894;
  const __int32_t * D.5895;
  long unsigned int D.5896;
  long unsigned int D.5897;
  const __int32_t * D.5898;
  long unsigned int D.5902;
  long unsigned int D.5903;
  const __int32_t * D.5904;
  char D.5905;

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

    {
      if (0 != 0) goto <D.5882>; else goto <D.5883>;
      <D.5882>:
      D.5884 = *string;
      D.5885 = (int) D.5884;
      D.5886 = __builtin_constant_p (D.5885);
      if (D.5886 != 0) goto <D.5887>; else goto <D.5888>;
      <D.5887>:
      {
        int __c;

        D.5884 = *string;
        __c = (int) D.5884;
        __c.24 = (unsigned int) __c;
        D.5891 = __c.24 + 128;
        if (D.5891 <= 383) goto <D.5892>; else goto <D.5893>;
        <D.5892>:
        D.5894 = __ctype_tolower_loc ();
        D.5895 = *D.5894;
        D.5896 = (long unsigned int) __c;
        D.5897 = D.5896 * 4;
        D.5898 = D.5895 + D.5897;
        iftmp.23 = *D.5898;
        goto <D.5899>;
        <D.5893>:
        iftmp.23 = __c;
        <D.5899>:
        __res = iftmp.23;
      }
      goto <D.5900>;
      <D.5888>:
      D.5884 = *string;
      D.5885 = (int) D.5884;
      __res = tolower (D.5885);
      <D.5900>:
      goto <D.5901>;
      <D.5883>:
      D.5894 = __ctype_tolower_loc ();
      D.5895 = *D.5894;
      D.5884 = *string;
      D.5902 = (long unsigned int) D.5884;
      D.5903 = D.5902 * 4;
      D.5904 = D.5895 + D.5903;
      __res = *D.5904;
      <D.5901>:
    }
    D.5328 = __res;
  }
  D.5905 = (char) D.5328;
  *string = D.5905;
  string = string + 1;
  <D.5330>:
  D.5884 = *string;
  if (D.5884 != 0) goto <D.5329>; else goto <D.5331>;
  <D.5331>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.5907;
  gchar iftmp.25;
  char D.5909;

  D.5909 = c + 191;
  if (D.5909 <= 25) goto <D.5910>; else goto <D.5911>;
  <D.5910>:
  iftmp.25 = c + 32;
  goto <D.5912>;
  <D.5911>:
  iftmp.25 = c;
  <D.5912>:
  D.5907 = iftmp.25;
  return D.5907;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.5916;
  long unsigned int D.5919;
  long int D.5920;
  long unsigned int D.5921;
  sizetype D.5922;
  char * D.5923;
  const gchar * D.5924;
  char D.5925;
  char D.5926;
  long int D.5927;
  char * ret;
  int i;

  if (str == 0B) goto <D.5914>; else goto <D.5915>;
  <D.5914>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.5916 = 0B;
  return D.5916;
  <D.5915>:
  if (len == -1) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  D.5919 = strlen (str);
  len = (gssize) D.5919;
  <D.5918>:
  D.5920 = len + 1;
  D.5921 = (long unsigned int) D.5920;
  ret = monoeg_malloc (D.5921);
  i = 0;
  goto <D.5342>;
  <D.5341>:
  D.5922 = (sizetype) i;
  D.5923 = ret + D.5922;
  D.5922 = (sizetype) i;
  D.5924 = str + D.5922;
  D.5925 = *D.5924;
  D.5926 = monoeg_g_ascii_tolower (D.5925);
  *D.5923 = D.5926;
  i = i + 1;
  <D.5342>:
  D.5927 = (long int) i;
  if (D.5927 < len) goto <D.5341>; else goto <D.5343>;
  <D.5343>:
  D.5922 = (sizetype) i;
  D.5923 = ret + D.5922;
  *D.5923 = 0;
  D.5916 = ret;
  return D.5916;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.5929;
  gchar iftmp.26;
  char D.5931;

  D.5931 = c + 159;
  if (D.5931 <= 25) goto <D.5932>; else goto <D.5933>;
  <D.5932>:
  iftmp.26 = c + 224;
  goto <D.5934>;
  <D.5933>:
  iftmp.26 = c;
  <D.5934>:
  D.5929 = iftmp.26;
  return D.5929;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.5938;
  long unsigned int D.5941;
  long int D.5942;
  long unsigned int D.5943;
  sizetype D.5944;
  char * D.5945;
  const gchar * D.5946;
  char D.5947;
  char D.5948;
  long int D.5949;
  char * ret;
  int i;

  if (str == 0B) goto <D.5936>; else goto <D.5937>;
  <D.5936>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.5938 = 0B;
  return D.5938;
  <D.5937>:
  if (len == -1) goto <D.5939>; else goto <D.5940>;
  <D.5939>:
  D.5941 = strlen (str);
  len = (gssize) D.5941;
  <D.5940>:
  D.5942 = len + 1;
  D.5943 = (long unsigned int) D.5942;
  ret = monoeg_malloc (D.5943);
  i = 0;
  goto <D.5354>;
  <D.5353>:
  D.5944 = (sizetype) i;
  D.5945 = ret + D.5944;
  D.5944 = (sizetype) i;
  D.5946 = str + D.5944;
  D.5947 = *D.5946;
  D.5948 = monoeg_ascii_toupper (D.5947);
  *D.5945 = D.5948;
  i = i + 1;
  <D.5354>:
  D.5949 = (long int) i;
  if (D.5949 < len) goto <D.5353>; else goto <D.5355>;
  <D.5355>:
  D.5944 = (sizetype) i;
  D.5945 = ret + D.5944;
  *D.5945 = 0;
  D.5938 = ret;
  return D.5938;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.5953;
  const gchar * s1.27;
  char D.5957;
  const gchar * s2.28;
  char D.5959;
  int D.5962;
  int D.5963;
  gsize i;

  if (s1 == 0B) goto <D.5951>; else goto <D.5952>;
  <D.5951>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.5953 = 0;
  return D.5953;
  <D.5952>:
  if (s2 == 0B) goto <D.5954>; else goto <D.5955>;
  <D.5954>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.5953 = 0;
  return D.5953;
  <D.5955>:
  i = 0;
  goto <D.5365>;
  <D.5364>:
  {
    gchar c1;
    gchar c2;

    s1.27 = s1;
    s1 = s1.27 + 1;
    D.5957 = *s1.27;
    c1 = monoeg_g_ascii_tolower (D.5957);
    s2.28 = s2;
    s2 = s2.28 + 1;
    D.5959 = *s2.28;
    c2 = monoeg_g_ascii_tolower (D.5959);
    if (c1 != c2) goto <D.5960>; else goto <D.5961>;
    <D.5960>:
    D.5962 = (int) c1;
    D.5963 = (int) c2;
    D.5953 = D.5962 - D.5963;
    return D.5953;
    <D.5961>:
  }
  i = i + 1;
  <D.5365>:
  if (i < n) goto <D.5364>; else goto <D.5366>;
  <D.5366>:
  D.5953 = 0;
  return D.5953;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.5967;
  const char * sp1.29;
  char D.5971;
  const char * sp2.30;
  char D.5973;
  int D.5976;
  int D.5977;
  char D.5978;
  int D.5979;
  char D.5980;
  int D.5981;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.5965>; else goto <D.5966>;
  <D.5965>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.5967 = 0;
  return D.5967;
  <D.5966>:
  if (s2 == 0B) goto <D.5968>; else goto <D.5969>;
  <D.5968>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.5967 = 0;
  return D.5967;
  <D.5969>:
  goto <D.5376>;
  <D.5375>:
  {
    char c1;
    char c2;

    sp1.29 = sp1;
    sp1 = sp1.29 + 1;
    D.5971 = *sp1.29;
    c1 = monoeg_g_ascii_tolower (D.5971);
    sp2.30 = sp2;
    sp2 = sp2.30 + 1;
    D.5973 = *sp2.30;
    c2 = monoeg_g_ascii_tolower (D.5973);
    if (c1 != c2) goto <D.5974>; else goto <D.5975>;
    <D.5974>:
    D.5976 = (int) c1;
    D.5977 = (int) c2;
    D.5967 = D.5976 - D.5977;
    return D.5967;
    <D.5975>:
  }
  <D.5376>:
  D.5978 = *sp1;
  if (D.5978 != 0) goto <D.5375>; else goto <D.5377>;
  <D.5377>:
  D.5978 = *sp1;
  D.5979 = (int) D.5978;
  D.5980 = *sp2;
  D.5981 = (int) D.5980;
  D.5967 = D.5979 - D.5981;
  return D.5967;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.5985;
  _Bool iftmp.31;
  char D.5991;
  int D.5992;
  int D.5993;
  void * D.5996;
  char * D.5997;
  gchar * ptr;

  if (string == 0B) goto <D.5983>; else goto <D.5984>;
  <D.5983>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.5985 = 0B;
  return D.5985;
  <D.5984>:
  if (delimiters == 0B) goto <D.5986>; else goto <D.5987>;
  <D.5986>:
  delimiters = "_-|> <.";
  <D.5987>:
  ptr = string;
  goto <D.5385>;
  <D.5384>:
  D.5991 = *ptr;
  D.5992 = (int) D.5991;
  D.5993 = __builtin_constant_p (D.5992);
  if (D.5993 != 0) goto <D.5994>; else goto <D.5989>;
  <D.5994>:
  D.5991 = *ptr;
  if (D.5991 == 0) goto <D.5995>; else goto <D.5989>;
  <D.5995>:
  D.5991 = *ptr;
  D.5992 = (int) D.5991;
  D.5996 = __rawmemchr (delimiters, D.5992);
  iftmp.31 = D.5996 != 0B;
  goto <D.5990>;
  <D.5989>:
  D.5991 = *ptr;
  D.5992 = (int) D.5991;
  D.5997 = __builtin_strchr (delimiters, D.5992);
  iftmp.31 = D.5997 != 0B;
  <D.5990>:
  if (iftmp.31 != 0) goto <D.5998>; else goto <D.5999>;
  <D.5998>:
  *ptr = new_delimiter;
  <D.5999>:
  ptr = ptr + 1;
  <D.5385>:
  D.5991 = *ptr;
  if (D.5991 != 0) goto <D.5384>; else goto <D.5386>;
  <D.5386>:
  D.5985 = string;
  return D.5985;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.6003;
  const gchar * s.32;
  gchar * d.33;
  long unsigned int D.6012;
  const gchar * s.34;
  char D.6014;
  long int s.35;
  long int src.36;
  long int D.6017;
  long int D.6018;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.6001>; else goto <D.6002>;
  <D.6001>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.6003 = 0;
  return D.6003;
  <D.6002>:
  if (dest == 0B) goto <D.6004>; else goto <D.6005>;
  <D.6004>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.6003 = 0;
  return D.6003;
  <D.6005>:
  len = dest_size;
  if (len == 0) goto <D.6006>; else goto <D.6007>;
  <D.6006>:
  D.6003 = 0;
  return D.6003;
  <D.6007>:
  s = src;
  d = dest;
  goto <D.5397>;
  <D.5396>:
  s.32 = s;
  s = s.32 + 1;
  c = *s.32;
  d.33 = d;
  d = d.33 + 1;
  *d.33 = c;
  if (c == 0) goto <D.6010>; else goto <D.6011>;
  <D.6010>:
  D.6012 = dest_size - len;
  D.6003 = D.6012 + 18446744073709551615;
  return D.6003;
  <D.6011>:
  <D.5397>:
  len = len + 18446744073709551615;
  if (len != 0) goto <D.5396>; else goto <D.5398>;
  <D.5398>:
  *d = 0;
  goto <D.5400>;
  <D.5399>:
  <D.5400>:
  s.34 = s;
  s = s.34 + 1;
  D.6014 = *s.34;
  if (D.6014 != 0) goto <D.5399>; else goto <D.5401>;
  <D.5401>:
  s.35 = (long int) s;
  src.36 = (long int) src;
  D.6017 = s.35 - src.36;
  D.6018 = D.6017 + -1;
  D.6003 = (gsize) D.6018;
  return D.6003;
}


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

  if (dest == 0B) goto <D.6020>; else goto <D.6021>;
  <D.6020>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.6022 = dest;
  return D.6022;
  <D.6021>:
  if (src == 0B) goto <D.6023>; else goto <D.6024>;
  <D.6023>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.6022 = dest;
  return D.6022;
  <D.6024>:
  D.6022 = stpcpy (dest, src);
  return D.6022;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
stpcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.6026;
  long unsigned int D.6027;

  D.6027 = __builtin_object_size (__dest, 1);
  D.6026 = __builtin___stpcpy_chk (__dest, __src, D.6027);
  return D.6026;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.6031;
  char D.6034;
  int D.6035;
  long unsigned int D.6036;
  long unsigned int D.6037;
  long unsigned int D.6038;
  int D.6039;
  gchar * res_ptr.37;
  gchar * res_ptr.38;
  gchar * res_ptr.39;
  gchar * res_ptr.40;
  unsigned char D.6050;
  char D.6051;
  gchar * res_ptr.41;
  unsigned char D.6053;
  char D.6054;
  char D.6055;
  gchar * res_ptr.42;
  char D.6057;
  char D.6058;
  gchar escaped[256];
  const gchar * ptr;
  gchar c;
  gchar op;
  gchar * result;
  gchar * res_ptr;

  try
    {
      if (source == 0B) goto <D.6029>; else goto <D.6030>;
      <D.6029>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.6031 = 0B;
      return D.6031;
      <D.6030>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.6032>; else goto <D.6033>;
      <D.6032>:
      ptr = exceptions;
      goto <D.5418>;
      <D.5417>:
      D.6034 = *ptr;
      D.6035 = (int) D.6034;
      escaped[D.6035] = 0;
      ptr = ptr + 1;
      <D.5418>:
      D.6034 = *ptr;
      if (D.6034 != 0) goto <D.5417>; else goto <D.5419>;
      <D.5419>:
      <D.6033>:
      D.6036 = strlen (source);
      D.6037 = D.6036 * 4;
      D.6038 = D.6037 + 1;
      result = monoeg_malloc (D.6038);
      res_ptr = result;
      ptr = source;
      goto <D.5421>;
      <D.5420>:
      c = *ptr;
      D.6039 = (int) c;
      op = escaped[D.6039];
      if (op == 0) goto <D.6040>; else goto <D.6041>;
      <D.6040>:
      res_ptr.37 = res_ptr;
      res_ptr = res_ptr.37 + 1;
      *res_ptr.37 = c;
      goto <D.6043>;
      <D.6041>:
      res_ptr.38 = res_ptr;
      res_ptr = res_ptr.38 + 1;
      *res_ptr.38 = 92;
      if (op != 1) goto <D.6045>; else goto <D.6046>;
      <D.6045>:
      res_ptr.39 = res_ptr;
      res_ptr = res_ptr.39 + 1;
      *res_ptr.39 = op;
      goto <D.6048>;
      <D.6046>:
      res_ptr.40 = res_ptr;
      res_ptr = res_ptr.40 + 1;
      D.6050 = c >> 6;
      D.6051 = D.6050 + 48;
      *res_ptr.40 = D.6051;
      res_ptr.41 = res_ptr;
      res_ptr = res_ptr.41 + 1;
      D.6053 = c >> 3;
      D.6054 = D.6053 & 7;
      D.6055 = D.6054 + 48;
      *res_ptr.41 = D.6055;
      res_ptr.42 = res_ptr;
      res_ptr = res_ptr.42 + 1;
      D.6057 = c & 7;
      D.6058 = D.6057 + 48;
      *res_ptr.42 = D.6058;
      <D.6048>:
      <D.6043>:
      ptr = ptr + 1;
      <D.5421>:
      D.6034 = *ptr;
      if (D.6034 != 0) goto <D.5420>; else goto <D.5422>;
      <D.5422>:
      *res_ptr = 0;
      D.6031 = result;
      return D.6031;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.6061;
  long unsigned int D.6062;

  D.6062 = __builtin_object_size (__dest, 0);
  D.6061 = __builtin___memcpy_chk (__dest, __src, __len, D.6062);
  return D.6061;
}


monoeg_g_ascii_xdigit_value (gchar c)
{
  gint D.6064;
  gint iftmp.43;
  const short unsigned int * * D.6066;
  const short unsigned int * D.6067;
  long unsigned int D.6068;
  long unsigned int D.6069;
  const short unsigned int * D.6070;
  short unsigned int D.6071;
  int D.6072;
  int D.6073;
  gint iftmp.44;
  char D.6077;
  int D.6080;
  gint iftmp.45;
  char D.6083;

  D.6066 = __ctype_b_loc ();
  D.6067 = *D.6066;
  D.6068 = (long unsigned int) c;
  D.6069 = D.6068 * 2;
  D.6070 = D.6067 + D.6069;
  D.6071 = *D.6070;
  D.6072 = (int) D.6071;
  D.6073 = D.6072 & 16;
  if (D.6073 != 0) goto <D.6074>; else goto <D.6075>;
  <D.6074>:
  D.6077 = c + 208;
  if (D.6077 <= 9) goto <D.6078>; else goto <D.6079>;
  <D.6078>:
  D.6080 = (int) c;
  iftmp.44 = D.6080 + -48;
  goto <D.6081>;
  <D.6079>:
  D.6083 = c + 159;
  if (D.6083 <= 5) goto <D.6084>; else goto <D.6085>;
  <D.6084>:
  D.6080 = (int) c;
  iftmp.45 = D.6080 + -87;
  goto <D.6086>;
  <D.6085>:
  D.6080 = (int) c;
  iftmp.45 = D.6080 + -55;
  <D.6086>:
  iftmp.44 = iftmp.45;
  <D.6081>:
  iftmp.43 = iftmp.44;
  goto <D.6087>;
  <D.6075>:
  iftmp.43 = -1;
  <D.6087>:
  D.6064 = iftmp.43;
  return D.6064;
}


monoeg_g_strnfill (gsize length, gchar fill_char)
{
  long unsigned int D.6089;
  int D.6090;
  gchar * D.6091;
  gchar * D.6092;
  gchar * ret;

  D.6089 = length + 1;
  ret = monoeg_malloc (D.6089);
  D.6090 = (int) fill_char;
  memset (ret, D.6090, length);
  D.6091 = ret + length;
  *D.6091 = 0;
  D.6092 = ret;
  return D.6092;
}


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

  D.6095 = __builtin_object_size (__dest, 0);
  D.6094 = __builtin___memset_chk (__dest, __ch, __len, D.6095);
  return D.6094;
}