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

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


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

  orig = str_array;
  if (str_array == 0B) goto <D.5331>; else goto <D.5332>;
  <D.5331>:
  return;
  <D.5332>:
  goto <D.4933>;
  <D.4932>:
  D.5333 = *str_array;
  monoeg_g_free (D.5333);
  str_array = str_array + 8;
  <D.4933>:
  D.5333 = *str_array;
  if (D.5333 != 0B) goto <D.4932>; else goto <D.4934>;
  <D.4934>:
  monoeg_g_free (orig);
}


monoeg_g_strdupv (gchar * * str_array)
{
  gchar * * D.5337;
  unsigned int D.5338;
  long unsigned int D.5339;
  long unsigned int D.5340;
  long unsigned int D.5341;
  long unsigned int D.5342;
  gchar * * D.5343;
  gchar * * D.5344;
  gchar * D.5345;
  gchar * D.5346;
  long unsigned int D.5347;
  long unsigned int D.5348;
  gchar * * D.5349;
  guint length;
  gchar * * ret;
  guint i;

  if (str_array == 0B) goto <D.5335>; else goto <D.5336>;
  <D.5335>:
  D.5337 = 0B;
  return D.5337;
  <D.5336>:
  length = monoeg_g_strv_length (str_array);
  D.5338 = length + 1;
  D.5339 = (long unsigned int) D.5338;
  D.5340 = D.5339 * 8;
  ret = monoeg_malloc0 (D.5340);
  i = 0;
  goto <D.4942>;
  <D.4941>:
  D.5341 = (long unsigned int) i;
  D.5342 = D.5341 * 8;
  D.5343 = ret + D.5342;
  D.5341 = (long unsigned int) i;
  D.5342 = D.5341 * 8;
  D.5344 = str_array + D.5342;
  D.5345 = *D.5344;
  D.5346 = monoeg_strdup (D.5345);
  *D.5343 = D.5346;
  i = i + 1;
  <D.4942>:
  D.5341 = (long unsigned int) i;
  D.5342 = D.5341 * 8;
  D.5344 = str_array + D.5342;
  D.5345 = *D.5344;
  if (D.5345 != 0B) goto <D.4941>; else goto <D.4943>;
  <D.4943>:
  D.5347 = (long unsigned int) length;
  D.5348 = D.5347 * 8;
  D.5349 = ret + D.5348;
  *D.5349 = 0B;
  D.5337 = ret;
  return D.5337;
}


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

  if (str != 0B) goto <D.5351>; else goto <D.5352>;
  <D.5351>:
  D.5353 = __strdup (str);
  return D.5353;
  <D.5352>:
  D.5353 = 0B;
  return D.5353;
}


monoeg_g_strv_length (gchar * * str_array)
{
  guint D.5357;
  long unsigned int D.5358;
  long unsigned int D.5359;
  gchar * * D.5360;
  gchar * D.5361;
  gint length;

  length = 0;
  if (str_array == 0B) goto <D.5355>; else goto <D.5356>;
  <D.5355>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 89, "str_array != NULL");
  D.5357 = 0;
  return D.5357;
  <D.5356>:
  length = 0;
  goto <D.4949>;
  <D.4948>:
  length = length + 1;
  <D.4949>:
  D.5358 = (long unsigned int) length;
  D.5359 = D.5358 * 8;
  D.5360 = str_array + D.5359;
  D.5361 = *D.5360;
  if (D.5361 != 0B) goto <D.4948>; else goto <D.4950>;
  <D.4950>:
  D.5357 = (guint) length;
  return D.5357;
}


monoeg_g_str_has_suffix (const gchar * str, const gchar * suffix)
{
  gboolean D.5365;
  int iftmp.0;
  sizetype D.5372;
  const gchar * D.5373;
  int D.5374;
  size_t str_length;
  size_t suffix_length;

  if (str == 0B) goto <D.5363>; else goto <D.5364>;
  <D.5363>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 100, "str != NULL");
  D.5365 = 0;
  return D.5365;
  <D.5364>:
  if (suffix == 0B) goto <D.5366>; else goto <D.5367>;
  <D.5366>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 101, "suffix != NULL");
  D.5365 = 0;
  return D.5365;
  <D.5367>:
  str_length = strlen (str);
  suffix_length = strlen (suffix);
  if (suffix_length <= str_length) goto <D.5371>; else goto <D.5369>;
  <D.5371>:
  D.5372 = str_length - suffix_length;
  D.5373 = str + D.5372;
  D.5374 = strncmp (D.5373, suffix, suffix_length);
  if (D.5374 == 0) goto <D.5375>; else goto <D.5369>;
  <D.5375>:
  iftmp.0 = 1;
  goto <D.5370>;
  <D.5369>:
  iftmp.0 = 0;
  <D.5370>:
  D.5365 = iftmp.0;
  return D.5365;
}


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

  if (str == 0B) goto <D.5377>; else goto <D.5378>;
  <D.5377>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 117, "str != NULL");
  D.5379 = 0;
  return D.5379;
  <D.5378>:
  if (prefix == 0B) goto <D.5380>; else goto <D.5381>;
  <D.5380>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 118, "prefix != NULL");
  D.5379 = 0;
  return D.5379;
  <D.5381>:
  str_length = strlen (str);
  prefix_length = strlen (prefix);
  if (prefix_length <= str_length) goto <D.5385>; else goto <D.5383>;
  <D.5385>:
  D.5386 = strncmp (str, prefix, prefix_length);
  if (D.5386 == 0) goto <D.5387>; else goto <D.5383>;
  <D.5387>:
  iftmp.1 = 1;
  goto <D.5384>;
  <D.5383>:
  iftmp.1 = 0;
  <D.5384>:
  D.5379 = iftmp.1;
  return D.5379;
}


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

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


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

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


monoeg_g_strdup_printf (const gchar * format)
{
  gchar * D.5398;
  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.5396>; else goto <D.5397>;
      <D.5396>:
      D.5398 = 0B;
      return D.5398;
      <D.5397>:
      D.5398 = ret;
      return D.5398;
    }
  finally
    {
      ret = {CLOBBER};
      args = {CLOBBER};
    }
}


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

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


monoeg_g_strconcat (const gchar * first)
{
  gchar * D.5405;
  long unsigned int D.5406;
  void * addr.2;
  unsigned int D.5410;
  void * D.5412;
  sizetype D.5413;
  unsigned int D.5414;
  void * D.5415;
  void * D.5416;
  long unsigned int D.5417;
  void * addr.3;
  unsigned int D.5421;
  sizetype D.5423;
  unsigned int D.5424;
  long unsigned int D.5425;
  char * D.5428;
  void * addr.4;
  unsigned int D.5432;
  sizetype D.5434;
  unsigned int D.5435;
  void * addr.5;
  unsigned int D.5439;
  sizetype D.5441;
  unsigned int D.5442;
  struct  args[1];
  size_t total;
  char * s;
  char * ret;

  try
    {
      total = 0;
      if (first == 0B) goto <D.5403>; else goto <D.5404>;
      <D.5403>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 169, "first != NULL");
      D.5405 = 0B;
      return D.5405;
      <D.5404>:
      D.5406 = strlen (first);
      total = D.5406 + total;
      __builtin_va_start (&args, 0);
      D.5410 = args.gp_offset;
      if (D.5410 >= 48) goto <D.5408>; else goto <D.5411>;
      <D.5411>:
      D.5412 = args.reg_save_area;
      D.5410 = args.gp_offset;
      D.5413 = (sizetype) D.5410;
      addr.2 = D.5412 + D.5413;
      D.5410 = args.gp_offset;
      D.5414 = D.5410 + 8;
      args.gp_offset = D.5414;
      goto <D.5409>;
      <D.5408>:
      D.5415 = args.overflow_arg_area;
      addr.2 = D.5415;
      D.5416 = D.5415 + 8;
      args.overflow_arg_area = D.5416;
      <D.5409>:
      s = MEM[(char * * {ref-all})addr.2];
      goto <D.5004>;
      <D.5003>:
      D.5417 = strlen (s);
      total = D.5417 + total;
      D.5421 = args.gp_offset;
      if (D.5421 >= 48) goto <D.5419>; else goto <D.5422>;
      <D.5422>:
      D.5412 = args.reg_save_area;
      D.5421 = args.gp_offset;
      D.5423 = (sizetype) D.5421;
      addr.3 = D.5412 + D.5423;
      D.5421 = args.gp_offset;
      D.5424 = D.5421 + 8;
      args.gp_offset = D.5424;
      goto <D.5420>;
      <D.5419>:
      D.5415 = args.overflow_arg_area;
      addr.3 = D.5415;
      D.5416 = D.5415 + 8;
      args.overflow_arg_area = D.5416;
      <D.5420>:
      s = MEM[(char * * {ref-all})addr.3];
      <D.5004>:
      if (s != 0B) goto <D.5003>; else goto <D.5005>;
      <D.5005>:
      __builtin_va_end (&args);
      D.5425 = total + 1;
      ret = monoeg_malloc (D.5425);
      if (ret == 0B) goto <D.5426>; else goto <D.5427>;
      <D.5426>:
      D.5405 = 0B;
      return D.5405;
      <D.5427>:
      D.5428 = ret + total;
      *D.5428 = 0;
      strcpy (ret, first);
      __builtin_va_start (&args, 0);
      D.5432 = args.gp_offset;
      if (D.5432 >= 48) goto <D.5430>; else goto <D.5433>;
      <D.5433>:
      D.5412 = args.reg_save_area;
      D.5432 = args.gp_offset;
      D.5434 = (sizetype) D.5432;
      addr.4 = D.5412 + D.5434;
      D.5432 = args.gp_offset;
      D.5435 = D.5432 + 8;
      args.gp_offset = D.5435;
      goto <D.5431>;
      <D.5430>:
      D.5415 = args.overflow_arg_area;
      addr.4 = D.5415;
      D.5416 = D.5415 + 8;
      args.overflow_arg_area = D.5416;
      <D.5431>:
      s = MEM[(char * * {ref-all})addr.4];
      goto <D.5007>;
      <D.5006>:
      strcat (ret, s);
      D.5439 = args.gp_offset;
      if (D.5439 >= 48) goto <D.5437>; else goto <D.5440>;
      <D.5440>:
      D.5412 = args.reg_save_area;
      D.5439 = args.gp_offset;
      D.5441 = (sizetype) D.5439;
      addr.5 = D.5412 + D.5441;
      D.5439 = args.gp_offset;
      D.5442 = D.5439 + 8;
      args.gp_offset = D.5442;
      goto <D.5438>;
      <D.5437>:
      D.5415 = args.overflow_arg_area;
      addr.5 = D.5415;
      D.5416 = D.5415 + 8;
      args.overflow_arg_area = D.5416;
      <D.5438>:
      s = MEM[(char * * {ref-all})addr.5];
      <D.5007>:
      if (s != 0B) goto <D.5006>; else goto <D.5008>;
      <D.5008>:
      __builtin_va_end (&args);
      D.5405 = ret;
      return D.5405;
    }
  finally
    {
      args = {CLOBBER};
    }
}


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

  D.5446 = __builtin_object_size (__dest, 1);
  D.5445 = __builtin___strcpy_chk (__dest, __src, D.5446);
  return D.5445;
}


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

  D.5449 = __builtin_object_size (__dest, 1);
  D.5448 = __builtin___strcat_chk (__dest, __src, D.5449);
  return D.5448;
}


monoeg_g_strsplit (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5453;
  char D.5456;
  long unsigned int D.5459;
  int D.5460;
  void * vector.6;
  gchar * * vector.7;
  gchar * D.5465;
  long unsigned int D.5466;
  long unsigned int D.5468;
  int D.5469;
  long unsigned int D.5472;
  char D.5474;
  long unsigned int D.5476;
  int D.5477;
  long int string.8;
  long int c.9;
  long int D.5482;
  int D.5062;
  long unsigned int D.5485;
  _Bool D.5488;
  _Bool D.5489;
  _Bool D.5490;
  int D.5074;
  gchar * D.5495;
  gchar * D.5497;
  void * vector.10;
  long unsigned int D.5504;
  long unsigned int D.5505;
  sizetype D.5506;
  gchar * * D.5507;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5451>; else goto <D.5452>;
      <D.5451>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 210, "string != NULL");
      D.5453 = 0B;
      return D.5453;
      <D.5452>:
      if (delimiter == 0B) goto <D.5454>; else goto <D.5455>;
      <D.5454>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 211, "delimiter != NULL");
      D.5453 = 0B;
      return D.5453;
      <D.5455>:
      D.5456 = *delimiter;
      if (D.5456 == 0) goto <D.5457>; else goto <D.5458>;
      <D.5457>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 212, "delimiter[0] != 0");
      D.5453 = 0B;
      return D.5453;
      <D.5458>:
      D.5459 = strlen (delimiter);
      D.5460 = strncmp (string, delimiter, D.5459);
      if (D.5460 == 0) goto <D.5461>; else goto <D.5462>;
      <D.5461>:
      vector.6 = monoeg_malloc (16);
      vector = vector.6;
      vector.7 = vector;
      D.5465 = monoeg_strdup ("");
      *vector.7 = D.5465;
      size = size + 1;
      D.5466 = strlen (delimiter);
      string = string + D.5466;
      goto <D.5467>;
      <D.5462>:
      vector = 0B;
      <D.5467>:
      goto <D.5064>;
      <D.5063>:
      c = string;
      D.5468 = strlen (delimiter);
      D.5469 = strncmp (string, delimiter, D.5468);
      if (D.5469 == 0) goto <D.5470>; else goto <D.5471>;
      <D.5470>:
      token = monoeg_strdup ("");
      D.5472 = strlen (delimiter);
      string = string + D.5472;
      goto <D.5473>;
      <D.5471>:
      goto <D.5051>;
      <D.5050>:
      string = string + 1;
      <D.5051>:
      D.5474 = *string;
      if (D.5474 != 0) goto <D.5475>; else goto <D.5052>;
      <D.5475>:
      D.5476 = strlen (delimiter);
      D.5477 = strncmp (string, delimiter, D.5476);
      if (D.5477 != 0) goto <D.5050>; else goto <D.5052>;
      <D.5052>:
      D.5474 = *string;
      if (D.5474 != 0) goto <D.5478>; else goto <D.5479>;
      <D.5478>:
      {
        gsize toklen;

        string.8 = (long int) string;
        c.9 = (long int) c;
        D.5482 = string.8 - c.9;
        toklen = (gsize) D.5482;
        token = monoeg_g_strndup (c, toklen);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.5062 = __builtin_strcmp (string, delimiter);
        }
        if (D.5062 != 0) goto <D.5483>; else goto <D.5484>;
        <D.5483>:
        D.5485 = strlen (delimiter);
        string = string + D.5485;
        <D.5484>:
      }
      goto <D.5486>;
      <D.5479>:
      token = monoeg_strdup (c);
      <D.5486>:
      <D.5473>:
      add_to_vector (&vector, size, token);
      size = size + 1;
      <D.5064>:
      D.5474 = *string;
      if (D.5474 != 0) goto <D.5487>; else goto <D.5065>;
      <D.5487>:
      D.5488 = max_tokens <= 0;
      D.5489 = size < max_tokens;
      D.5490 = D.5488 | D.5489;
      if (D.5490 != 0) goto <D.5063>; else goto <D.5065>;
      <D.5065>:
      D.5474 = *string;
      if (D.5474 != 0) goto <D.5491>; else goto <D.5492>;
      <D.5491>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.5074 = __builtin_strcmp (string, delimiter);
      }
      if (D.5074 == 0) goto <D.5493>; else goto <D.5494>;
      <D.5493>:
      D.5495 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5495);
      goto <D.5496>;
      <D.5494>:
      D.5497 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5497);
      <D.5496>:
      size = size + 1;
      <D.5492>:
      vector.7 = vector;
      if (vector.7 == 0B) goto <D.5498>; else goto <D.5499>;
      <D.5498>:
      vector.10 = monoeg_malloc (16);
      vector = vector.10;
      vector.7 = vector;
      *vector.7 = 0B;
      goto <D.5501>;
      <D.5499>:
      if (size > 0) goto <D.5502>; else goto <D.5503>;
      <D.5502>:
      vector.7 = vector;
      D.5504 = (long unsigned int) size;
      D.5505 = D.5504 * 8;
      D.5506 = D.5505 + 18446744073709551608;
      D.5507 = vector.7 + D.5506;
      *D.5507 = 0B;
      <D.5503>:
      <D.5501>:
      D.5453 = vector;
      return D.5453;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


add_to_vector (gchar * * * vector, int size, gchar * token)
{
  gchar * * iftmp.11;
  gchar * * D.5511;
  int D.5515;
  long unsigned int D.5516;
  long unsigned int D.5517;
  long unsigned int D.5518;
  long unsigned int D.5519;
  sizetype D.5520;
  gchar * * D.5521;

  D.5511 = *vector;
  if (D.5511 == 0B) goto <D.5512>; else goto <D.5513>;
  <D.5512>:
  iftmp.11 = monoeg_malloc (16);
  goto <D.5514>;
  <D.5513>:
  D.5515 = size + 1;
  D.5516 = (long unsigned int) D.5515;
  D.5517 = D.5516 * 8;
  D.5511 = *vector;
  iftmp.11 = monoeg_realloc (D.5511, D.5517);
  <D.5514>:
  *vector = iftmp.11;
  D.5511 = *vector;
  D.5518 = (long unsigned int) size;
  D.5519 = D.5518 * 8;
  D.5520 = D.5519 + 18446744073709551608;
  D.5521 = D.5511 + D.5520;
  *D.5521 = token;
}


monoeg_g_strsplit_set (const gchar * string, const gchar * delimiter, gint max_tokens)
{
  gchar * * D.5524;
  char D.5527;
  char D.5530;
  int D.5531;
  int D.5532;
  void * vector.12;
  gchar * * vector.13;
  gchar * D.5537;
  int D.5539;
  long int string.14;
  long int c.15;
  long int D.5544;
  _Bool D.5549;
  _Bool D.5550;
  _Bool D.5551;
  _Bool D.5552;
  _Bool D.5553;
  _Bool D.5554;
  gchar * D.5559;
  char D.5561;
  gchar * D.5564;
  gchar * D.5566;
  void * vector.16;
  long unsigned int D.5573;
  long unsigned int D.5574;
  sizetype D.5575;
  gchar * * D.5576;
  const gchar * c;
  gchar * token;
  gchar * * vector;
  gint size;

  try
    {
      size = 1;
      if (string == 0B) goto <D.5522>; else goto <D.5523>;
      <D.5522>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 293, "string != NULL");
      D.5524 = 0B;
      return D.5524;
      <D.5523>:
      if (delimiter == 0B) goto <D.5525>; else goto <D.5526>;
      <D.5525>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 294, "delimiter != NULL");
      D.5524 = 0B;
      return D.5524;
      <D.5526>:
      D.5527 = *delimiter;
      if (D.5527 == 0) goto <D.5528>; else goto <D.5529>;
      <D.5528>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 295, "delimiter[0] != 0");
      D.5524 = 0B;
      return D.5524;
      <D.5529>:
      D.5530 = *string;
      D.5531 = (int) D.5530;
      D.5532 = charcmp (D.5531, delimiter);
      if (D.5532 != 0) goto <D.5533>; else goto <D.5534>;
      <D.5533>:
      vector.12 = monoeg_malloc (16);
      vector = vector.12;
      vector.13 = vector;
      D.5537 = monoeg_strdup ("");
      *vector.13 = D.5537;
      size = size + 1;
      string = string + 1;
      goto <D.5538>;
      <D.5534>:
      vector = 0B;
      <D.5538>:
      c = string;
      goto <D.5093>;
      <D.5092>:
      D.5530 = *string;
      D.5531 = (int) D.5530;
      D.5539 = charcmp (D.5531, delimiter);
      if (D.5539 != 0) goto <D.5540>; else goto <D.5541>;
      <D.5540>:
      {
        gsize toklen;

        string.14 = (long int) string;
        c.15 = (long int) c;
        D.5544 = string.14 - c.15;
        toklen = (gsize) D.5544;
        if (toklen == 0) goto <D.5545>; else goto <D.5546>;
        <D.5545>:
        token = monoeg_strdup ("");
        goto <D.5547>;
        <D.5546>:
        token = monoeg_g_strndup (c, toklen);
        <D.5547>:
        c = string + 1;
        add_to_vector (&vector, size, token);
        size = size + 1;
      }
      <D.5541>:
      string = string + 1;
      <D.5093>:
      D.5530 = *string;
      if (D.5530 != 0) goto <D.5548>; else goto <D.5094>;
      <D.5548>:
      D.5549 = max_tokens <= 0;
      D.5550 = size < max_tokens;
      D.5551 = D.5549 | D.5550;
      if (D.5551 != 0) goto <D.5092>; else goto <D.5094>;
      <D.5094>:
      D.5552 = max_tokens > 0;
      D.5553 = size >= max_tokens;
      D.5554 = D.5552 & D.5553;
      if (D.5554 != 0) goto <D.5555>; else goto <D.5556>;
      <D.5555>:
      D.5530 = *string;
      if (D.5530 != 0) goto <D.5557>; else goto <D.5558>;
      <D.5557>:
      D.5559 = monoeg_strdup (string);
      add_to_vector (&vector, size, D.5559);
      size = size + 1;
      <D.5558>:
      goto <D.5560>;
      <D.5556>:
      D.5561 = *c;
      if (D.5561 != 0) goto <D.5562>; else goto <D.5563>;
      <D.5562>:
      D.5564 = monoeg_strdup (c);
      add_to_vector (&vector, size, D.5564);
      size = size + 1;
      goto <D.5565>;
      <D.5563>:
      D.5566 = monoeg_strdup ("");
      add_to_vector (&vector, size, D.5566);
      size = size + 1;
      <D.5565>:
      <D.5560>:
      vector.13 = vector;
      if (vector.13 == 0B) goto <D.5567>; else goto <D.5568>;
      <D.5567>:
      vector.16 = monoeg_malloc (16);
      vector = vector.16;
      vector.13 = vector;
      *vector.13 = 0B;
      goto <D.5570>;
      <D.5568>:
      if (size > 0) goto <D.5571>; else goto <D.5572>;
      <D.5571>:
      vector.13 = vector;
      D.5573 = (long unsigned int) size;
      D.5574 = D.5573 * 8;
      D.5575 = D.5574 + 18446744073709551608;
      D.5576 = vector.13 + D.5575;
      *D.5576 = 0B;
      <D.5572>:
      <D.5570>:
      D.5524 = vector;
      return D.5524;
    }
  finally
    {
      vector = {CLOBBER};
    }
}


charcmp (gchar testchar, const gchar * compare)
{
  char D.5579;
  gboolean D.5582;

  goto <D.5080>;
  <D.5079>:
  D.5579 = *compare;
  if (D.5579 == testchar) goto <D.5580>; else goto <D.5581>;
  <D.5580>:
  D.5582 = 1;
  return D.5582;
  <D.5581>:
  compare = compare + 1;
  <D.5080>:
  D.5579 = *compare;
  if (D.5579 != 0) goto <D.5079>; else goto <D.5081>;
  <D.5081>:
  D.5582 = 0;
  return D.5582;
}


monoeg_g_strreverse (gchar * str)
{
  gchar * D.5586;
  char D.5587;
  long unsigned int D.5590;
  gchar * D.5591;
  gchar * D.5592;
  char D.5593;
  size_t i;
  size_t j;
  gchar c;

  if (str == 0B) goto <D.5584>; else goto <D.5585>;
  <D.5584>:
  D.5586 = 0B;
  return D.5586;
  <D.5585>:
  D.5587 = *str;
  if (D.5587 == 0) goto <D.5588>; else goto <D.5589>;
  <D.5588>:
  D.5586 = str;
  return D.5586;
  <D.5589>:
  i = 0;
  D.5590 = strlen (str);
  j = D.5590 + 18446744073709551615;
  goto <D.5102>;
  <D.5101>:
  D.5591 = str + i;
  c = *D.5591;
  D.5591 = str + i;
  D.5592 = str + j;
  D.5593 = *D.5592;
  *D.5591 = D.5593;
  D.5592 = str + j;
  *D.5592 = c;
  i = i + 1;
  j = j + 18446744073709551615;
  <D.5102>:
  if (i < j) goto <D.5101>; else goto <D.5103>;
  <D.5103>:
  D.5586 = str;
  return D.5586;
}


monoeg_g_strjoin (const gchar * separator)
{
  void * addr.17;
  unsigned int D.5601;
  void * D.5603;
  sizetype D.5604;
  unsigned int D.5605;
  void * D.5606;
  void * D.5607;
  long unsigned int D.5608;
  void * addr.18;
  unsigned int D.5612;
  sizetype D.5614;
  unsigned int D.5615;
  gchar * D.5618;
  _Bool D.5619;
  _Bool D.5620;
  _Bool D.5621;
  long unsigned int D.5624;
  void * addr.19;
  unsigned int D.5628;
  sizetype D.5630;
  unsigned int D.5631;
  void * addr.20;
  unsigned int D.5635;
  sizetype D.5637;
  unsigned int D.5638;
  void * addr.21;
  unsigned int D.5644;
  sizetype D.5646;
  unsigned int D.5647;
  struct  args[1];
  char * res;
  char * s;
  char * r;
  size_t len;
  size_t slen;

  try
    {
      if (separator != 0B) goto <D.5595>; else goto <D.5596>;
      <D.5595>:
      slen = strlen (separator);
      goto <D.5597>;
      <D.5596>:
      slen = 0;
      <D.5597>:
      len = 0;
      __builtin_va_start (&args, 0);
      D.5601 = args.gp_offset;
      if (D.5601 >= 48) goto <D.5599>; else goto <D.5602>;
      <D.5602>:
      D.5603 = args.reg_save_area;
      D.5601 = args.gp_offset;
      D.5604 = (sizetype) D.5601;
      addr.17 = D.5603 + D.5604;
      D.5601 = args.gp_offset;
      D.5605 = D.5601 + 8;
      args.gp_offset = D.5605;
      goto <D.5600>;
      <D.5599>:
      D.5606 = args.overflow_arg_area;
      addr.17 = D.5606;
      D.5607 = D.5606 + 8;
      args.overflow_arg_area = D.5607;
      <D.5600>:
      s = MEM[(char * * {ref-all})addr.17];
      goto <D.5114>;
      <D.5113>:
      D.5608 = strlen (s);
      len = D.5608 + len;
      len = len + slen;
      D.5612 = args.gp_offset;
      if (D.5612 >= 48) goto <D.5610>; else goto <D.5613>;
      <D.5613>:
      D.5603 = args.reg_save_area;
      D.5612 = args.gp_offset;
      D.5614 = (sizetype) D.5612;
      addr.18 = D.5603 + D.5614;
      D.5612 = args.gp_offset;
      D.5615 = D.5612 + 8;
      args.gp_offset = D.5615;
      goto <D.5611>;
      <D.5610>:
      D.5606 = args.overflow_arg_area;
      addr.18 = D.5606;
      D.5607 = D.5606 + 8;
      args.overflow_arg_area = D.5607;
      <D.5611>:
      s = MEM[(char * * {ref-all})addr.18];
      <D.5114>:
      if (s != 0B) goto <D.5113>; else goto <D.5115>;
      <D.5115>:
      __builtin_va_end (&args);
      if (len == 0) goto <D.5616>; else goto <D.5617>;
      <D.5616>:
      D.5618 = monoeg_strdup ("");
      return D.5618;
      <D.5617>:
      D.5619 = slen != 0;
      D.5620 = len != 0;
      D.5621 = D.5619 & D.5620;
      if (D.5621 != 0) goto <D.5622>; else goto <D.5623>;
      <D.5622>:
      len = len - slen;
      <D.5623>:
      D.5624 = len + 1;
      res = monoeg_malloc (D.5624);
      __builtin_va_start (&args, 0);
      D.5628 = args.gp_offset;
      if (D.5628 >= 48) goto <D.5626>; else goto <D.5629>;
      <D.5629>:
      D.5603 = args.reg_save_area;
      D.5628 = args.gp_offset;
      D.5630 = (sizetype) D.5628;
      addr.19 = D.5603 + D.5630;
      D.5628 = args.gp_offset;
      D.5631 = D.5628 + 8;
      args.gp_offset = D.5631;
      goto <D.5627>;
      <D.5626>:
      D.5606 = args.overflow_arg_area;
      addr.19 = D.5606;
      D.5607 = D.5606 + 8;
      args.overflow_arg_area = D.5607;
      <D.5627>:
      s = MEM[(char * * {ref-all})addr.19];
      r = monoeg_g_stpcpy (res, s);
      D.5635 = args.gp_offset;
      if (D.5635 >= 48) goto <D.5633>; else goto <D.5636>;
      <D.5636>:
      D.5603 = args.reg_save_area;
      D.5635 = args.gp_offset;
      D.5637 = (sizetype) D.5635;
      addr.20 = D.5603 + D.5637;
      D.5635 = args.gp_offset;
      D.5638 = D.5635 + 8;
      args.gp_offset = D.5638;
      goto <D.5634>;
      <D.5633>:
      D.5606 = args.overflow_arg_area;
      addr.20 = D.5606;
      D.5607 = D.5606 + 8;
      args.overflow_arg_area = D.5607;
      <D.5634>:
      s = MEM[(char * * {ref-all})addr.20];
      goto <D.5117>;
      <D.5116>:
      if (separator != 0B) goto <D.5639>; else goto <D.5640>;
      <D.5639>:
      r = monoeg_g_stpcpy (r, separator);
      <D.5640>:
      r = monoeg_g_stpcpy (r, s);
      D.5644 = args.gp_offset;
      if (D.5644 >= 48) goto <D.5642>; else goto <D.5645>;
      <D.5645>:
      D.5603 = args.reg_save_area;
      D.5644 = args.gp_offset;
      D.5646 = (sizetype) D.5644;
      addr.21 = D.5603 + D.5646;
      D.5644 = args.gp_offset;
      D.5647 = D.5644 + 8;
      args.gp_offset = D.5647;
      goto <D.5643>;
      <D.5642>:
      D.5606 = args.overflow_arg_area;
      addr.21 = D.5606;
      D.5607 = D.5606 + 8;
      args.overflow_arg_area = D.5607;
      <D.5643>:
      s = MEM[(char * * {ref-all})addr.21];
      <D.5117>:
      if (s != 0B) goto <D.5116>; else goto <D.5118>;
      <D.5118>:
      __builtin_va_end (&args);
      D.5618 = res;
      return D.5618;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_strjoinv (const gchar * separator, gchar * * str_array)
{
  long unsigned int D.5653;
  gchar * * D.5654;
  gchar * D.5655;
  long unsigned int D.5656;
  gchar * D.5659;
  _Bool D.5660;
  _Bool D.5661;
  _Bool D.5662;
  long unsigned int D.5665;
  gchar * D.5666;
  char * res;
  char * r;
  size_t slen;
  size_t len;
  size_t i;

  if (separator != 0B) goto <D.5650>; else goto <D.5651>;
  <D.5650>:
  slen = strlen (separator);
  goto <D.5652>;
  <D.5651>:
  slen = 0;
  <D.5652>:
  len = 0;
  i = 0;
  goto <D.5129>;
  <D.5128>:
  D.5653 = i * 8;
  D.5654 = str_array + D.5653;
  D.5655 = *D.5654;
  D.5656 = strlen (D.5655);
  len = D.5656 + len;
  len = len + slen;
  i = i + 1;
  <D.5129>:
  D.5653 = i * 8;
  D.5654 = str_array + D.5653;
  D.5655 = *D.5654;
  if (D.5655 != 0B) goto <D.5128>; else goto <D.5130>;
  <D.5130>:
  if (len == 0) goto <D.5657>; else goto <D.5658>;
  <D.5657>:
  D.5659 = monoeg_strdup ("");
  return D.5659;
  <D.5658>:
  D.5660 = slen != 0;
  D.5661 = len != 0;
  D.5662 = D.5660 & D.5661;
  if (D.5662 != 0) goto <D.5663>; else goto <D.5664>;
  <D.5663>:
  len = len - slen;
  <D.5664>:
  D.5665 = len + 1;
  res = monoeg_malloc (D.5665);
  D.5666 = *str_array;
  r = monoeg_g_stpcpy (res, D.5666);
  i = 1;
  goto <D.5132>;
  <D.5131>:
  if (separator != 0B) goto <D.5667>; else goto <D.5668>;
  <D.5667>:
  r = monoeg_g_stpcpy (r, separator);
  <D.5668>:
  D.5653 = i * 8;
  D.5654 = str_array + D.5653;
  D.5655 = *D.5654;
  r = monoeg_g_stpcpy (r, D.5655);
  i = i + 1;
  <D.5132>:
  D.5653 = i * 8;
  D.5654 = str_array + D.5653;
  D.5655 = *D.5654;
  if (D.5655 != 0B) goto <D.5131>; else goto <D.5133>;
  <D.5133>:
  D.5659 = res;
  return D.5659;
}


monoeg_g_strchug (gchar * str)
{
  gchar * D.5672;
  char D.5673;
  const short unsigned int * * D.5675;
  const short unsigned int * D.5676;
  long unsigned int D.5677;
  long unsigned int D.5678;
  const short unsigned int * D.5679;
  short unsigned int D.5680;
  int D.5681;
  int D.5682;
  long unsigned int D.5685;
  long int str.22;
  long int tmp.23;
  long int D.5688;
  long unsigned int D.5689;
  long unsigned int D.5690;
  size_t len;
  gchar * tmp;

  if (str == 0B) goto <D.5670>; else goto <D.5671>;
  <D.5670>:
  D.5672 = 0B;
  return D.5672;
  <D.5671>:
  tmp = str;
  goto <D.5140>;
  <D.5139>:
  tmp = tmp + 1;
  <D.5140>:
  D.5673 = *tmp;
  if (D.5673 != 0) goto <D.5674>; else goto <D.5141>;
  <D.5674>:
  D.5675 = __ctype_b_loc ();
  D.5676 = *D.5675;
  D.5673 = *tmp;
  D.5677 = (long unsigned int) D.5673;
  D.5678 = D.5677 * 2;
  D.5679 = D.5676 + D.5678;
  D.5680 = *D.5679;
  D.5681 = (int) D.5680;
  D.5682 = D.5681 & 8192;
  if (D.5682 != 0) goto <D.5139>; else goto <D.5141>;
  <D.5141>:
  if (str != tmp) goto <D.5683>; else goto <D.5684>;
  <D.5683>:
  D.5685 = strlen (str);
  str.22 = (long int) str;
  tmp.23 = (long int) tmp;
  D.5688 = str.22 - tmp.23;
  D.5689 = (long unsigned int) D.5688;
  D.5690 = D.5685 + D.5689;
  len = D.5690 + 1;
  memmove (str, tmp, len);
  <D.5684>:
  D.5672 = str;
  return D.5672;
}


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

  D.5693 = __builtin_object_size (__dest, 0);
  D.5692 = __builtin___memmove_chk (__dest, __src, __len, D.5693);
  return D.5692;
}


monoeg_g_strchomp (gchar * str)
{
  gchar * D.5697;
  long unsigned int D.5698;
  sizetype D.5699;
  char D.5700;
  const short unsigned int * * D.5702;
  const short unsigned int * D.5703;
  long unsigned int D.5704;
  long unsigned int D.5705;
  const short unsigned int * D.5706;
  short unsigned int D.5707;
  int D.5708;
  int D.5709;
  gchar * D.5710;
  gchar * tmp;

  if (str == 0B) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  D.5697 = 0B;
  return D.5697;
  <D.5696>:
  D.5698 = strlen (str);
  D.5699 = D.5698 + 18446744073709551615;
  tmp = str + D.5699;
  goto <D.5147>;
  <D.5146>:
  tmp = tmp + 18446744073709551615;
  <D.5147>:
  D.5700 = *tmp;
  if (D.5700 != 0) goto <D.5701>; else goto <D.5148>;
  <D.5701>:
  D.5702 = __ctype_b_loc ();
  D.5703 = *D.5702;
  D.5700 = *tmp;
  D.5704 = (long unsigned int) D.5700;
  D.5705 = D.5704 * 2;
  D.5706 = D.5703 + D.5705;
  D.5707 = *D.5706;
  D.5708 = (int) D.5707;
  D.5709 = D.5708 & 8192;
  if (D.5709 != 0) goto <D.5146>; else goto <D.5148>;
  <D.5148>:
  D.5710 = tmp + 1;
  *D.5710 = 0;
  D.5697 = str;
  return D.5697;
}


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

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


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

  stdout.24 = stdout;
  D.5715 = __vfprintf_chk (stdout.24, 1, __fmt, __ap);
  return D.5715;
}


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

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


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

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


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

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


vsprintf (char * restrict __s, const char * restrict __fmt, struct  * __ap)
{
  int D.5726;
  long unsigned int D.5727;

  D.5727 = __builtin_object_size (__s, 1);
  D.5726 = __builtin___vsprintf_chk (__s, 1, D.5727, __fmt, __ap);
  return D.5726;
}


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

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


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

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


monoeg_g_filename_to_uri (const gchar * filename, const gchar * hostname, struct GError * * error)
{
  gchar * D.5737;
  int D.5740;
  struct GError * D.5745;
  long unsigned int D.5746;
  char D.5747;
  int D.5748;
  int D.5749;
  long unsigned int D.5753;
  int D.5754;
  char * rp.25;
  char * rp.26;
  unsigned char D.5759;
  unsigned char D.5760;
  int D.5761;
  char D.5762;
  char * rp.27;
  int D.5764;
  int D.5765;
  char D.5766;
  char * rp.28;
  size_t n;
  char * ret;
  char * rp;
  const char * p;
  const char * uriPrefix;

  uriPrefix = "file://";
  if (filename == 0B) goto <D.5735>; else goto <D.5736>;
  <D.5735>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 564, "filename != NULL");
  D.5737 = 0B;
  return D.5737;
  <D.5736>:
  if (hostname != 0B) goto <D.5738>; else goto <D.5739>;
  <D.5738>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_to_uri: hostname not handled");
  <D.5739>:
  D.5740 = monoeg_g_path_is_absolute (filename);
  if (D.5740 == 0) goto <D.5741>; else goto <D.5742>;
  <D.5741>:
  if (error != 0B) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  D.5745 = monoeg_g_error_new (0B, 2, "Not an absolute filename");
  *error = D.5745;
  <D.5744>:
  D.5737 = 0B;
  return D.5737;
  <D.5742>:
  D.5746 = strlen (uriPrefix);
  n = D.5746 + 1;
  p = filename;
  goto <D.5188>;
  <D.5187>:
  D.5747 = *p;
  D.5748 = (int) D.5747;
  D.5749 = char_needs_encoding (D.5748);
  if (D.5749 != 0) goto <D.5750>; else goto <D.5751>;
  <D.5750>:
  n = n + 3;
  goto <D.5752>;
  <D.5751>:
  n = n + 1;
  <D.5752>:
  p = p + 1;
  <D.5188>:
  D.5747 = *p;
  if (D.5747 != 0) goto <D.5187>; else goto <D.5189>;
  <D.5189>:
  ret = monoeg_malloc (n);
  strcpy (ret, uriPrefix);
  p = filename;
  D.5753 = strlen (ret);
  rp = ret + D.5753;
  goto <D.5191>;
  <D.5190>:
  D.5747 = *p;
  D.5748 = (int) D.5747;
  D.5754 = char_needs_encoding (D.5748);
  if (D.5754 != 0) goto <D.5755>; else goto <D.5756>;
  <D.5755>:
  rp.25 = rp;
  rp = rp.25 + 1;
  *rp.25 = 37;
  rp.26 = rp;
  rp = rp.26 + 1;
  D.5747 = *p;
  D.5759 = (unsigned char) D.5747;
  D.5760 = D.5759 >> 4;
  D.5761 = (int) D.5760;
  D.5762 = hx[D.5761];
  *rp.26 = D.5762;
  rp.27 = rp;
  rp = rp.27 + 1;
  D.5747 = *p;
  D.5759 = (unsigned char) D.5747;
  D.5764 = (int) D.5759;
  D.5765 = D.5764 & 15;
  D.5766 = hx[D.5765];
  *rp.27 = D.5766;
  goto <D.5767>;
  <D.5756>:
  rp.28 = rp;
  rp = rp.28 + 1;
  D.5747 = *p;
  *rp.28 = D.5747;
  <D.5767>:
  p = p + 1;
  <D.5191>:
  D.5747 = *p;
  if (D.5747 != 0) goto <D.5190>; else goto <D.5192>;
  <D.5192>:
  *rp = 0;
  D.5737 = ret;
  return D.5737;
}


char_needs_encoding (char c)
{
  gboolean D.5772;
  unsigned char c.29;
  unsigned char D.5776;
  _Bool D.5777;
  unsigned char D.5778;
  _Bool D.5779;
  _Bool D.5780;
  unsigned char D.5782;
  _Bool D.5784;
  _Bool D.5785;
  _Bool D.5786;
  _Bool D.5788;
  _Bool D.5789;
  _Bool D.5790;

  if (c < 0) goto <D.5770>; else goto <D.5771>;
  <D.5770>:
  D.5772 = 1;
  return D.5772;
  <D.5771>:
  c.29 = (unsigned char) c;
  D.5776 = c.29 + 192;
  D.5777 = D.5776 <= 26;
  c.29 = (unsigned char) c;
  D.5778 = c.29 + 159;
  D.5779 = D.5778 <= 25;
  D.5780 = D.5777 | D.5779;
  if (D.5780 != 0) goto <D.5773>; else goto <D.5781>;
  <D.5781>:
  c.29 = (unsigned char) c;
  D.5782 = c.29 + 218;
  if (D.5782 <= 20) goto <D.5773>; else goto <D.5783>;
  <D.5783>:
  D.5784 = c == 33;
  D.5785 = c == 36;
  D.5786 = D.5784 | D.5785;
  if (D.5786 != 0) goto <D.5773>; else goto <D.5787>;
  <D.5787>:
  D.5788 = c == 95;
  D.5789 = c == 61;
  D.5790 = D.5788 | D.5789;
  if (D.5790 != 0) goto <D.5773>; else goto <D.5791>;
  <D.5791>:
  if (c == 126) goto <D.5773>; else goto <D.5774>;
  <D.5773>:
  D.5772 = 0;
  return D.5772;
  <D.5774>:
  D.5772 = 1;
  return D.5772;
}


monoeg_g_filename_from_uri (const gchar * uri, gchar * * hostname, struct GError * * error)
{
  gchar * D.5795;
  int D.5798;
  struct GError * D.5803;
  char D.5804;
  const char * D.5809;
  char D.5810;
  const char * D.5812;
  char D.5813;
  const short unsigned int * * D.5815;
  const short unsigned int * D.5816;
  long unsigned int D.5817;
  long unsigned int D.5818;
  const short unsigned int * D.5819;
  short unsigned int D.5820;
  int D.5821;
  int D.5822;
  long unsigned int D.5824;
  long unsigned int D.5825;
  const short unsigned int * D.5826;
  short unsigned int D.5827;
  int D.5828;
  int D.5829;
  struct GError * D.5833;
  int D.5834;
  long unsigned int D.5835;
  sizetype D.5836;
  char * D.5837;
  char * r.30;
  int D.5841;
  int D.5842;
  int D.5843;
  char D.5844;
  int D.5845;
  int D.5846;
  char D.5847;
  char D.5848;
  char * r.31;
  const char * p;
  char * r;
  char * result;
  int flen;

  flen = 0;
  if (uri == 0B) goto <D.5793>; else goto <D.5794>;
  <D.5793>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 629, "uri != NULL");
  D.5795 = 0B;
  return D.5795;
  <D.5794>:
  if (hostname != 0B) goto <D.5796>; else goto <D.5797>;
  <D.5796>:
  monoeg_g_log (0B, 16, "%s", "eglib: g_filename_from_uri: hostname not handled");
  <D.5797>:
  D.5798 = strncmp (uri, "file:///", 8);
  if (D.5798 != 0) goto <D.5799>; else goto <D.5800>;
  <D.5799>:
  if (error != 0B) goto <D.5801>; else goto <D.5802>;
  <D.5801>:
  D.5803 = monoeg_g_error_new (0B, 2, "URI does not start with the file: scheme");
  *error = D.5803;
  <D.5802>:
  D.5795 = 0B;
  return D.5795;
  <D.5800>:
  p = uri + 8;
  goto <D.5215>;
  <D.5214>:
  D.5804 = *p;
  if (D.5804 == 37) goto <D.5805>; else goto <D.5806>;
  <D.5805>:
  D.5809 = p + 1;
  D.5810 = *D.5809;
  if (D.5810 != 0) goto <D.5811>; else goto <D.5807>;
  <D.5811>:
  D.5812 = p + 2;
  D.5813 = *D.5812;
  if (D.5813 != 0) goto <D.5814>; else goto <D.5807>;
  <D.5814>:
  D.5815 = __ctype_b_loc ();
  D.5816 = *D.5815;
  D.5809 = p + 1;
  D.5810 = *D.5809;
  D.5817 = (long unsigned int) D.5810;
  D.5818 = D.5817 * 2;
  D.5819 = D.5816 + D.5818;
  D.5820 = *D.5819;
  D.5821 = (int) D.5820;
  D.5822 = D.5821 & 4096;
  if (D.5822 != 0) goto <D.5823>; else goto <D.5807>;
  <D.5823>:
  D.5815 = __ctype_b_loc ();
  D.5816 = *D.5815;
  D.5812 = p + 2;
  D.5813 = *D.5812;
  D.5824 = (long unsigned int) D.5813;
  D.5825 = D.5824 * 2;
  D.5826 = D.5816 + D.5825;
  D.5827 = *D.5826;
  D.5828 = (int) D.5827;
  D.5829 = D.5828 & 4096;
  if (D.5829 != 0) goto <D.5830>; else goto <D.5807>;
  <D.5830>:
  p = p + 2;
  goto <D.5808>;
  <D.5807>:
  if (error != 0B) goto <D.5831>; else goto <D.5832>;
  <D.5831>:
  D.5833 = monoeg_g_error_new (0B, 2, "URI contains an invalid escape sequence");
  *error = D.5833;
  <D.5832>:
  D.5795 = 0B;
  return D.5795;
  <D.5808>:
  <D.5806>:
  flen = flen + 1;
  p = p + 1;
  <D.5215>:
  D.5804 = *p;
  if (D.5804 != 0) goto <D.5214>; else goto <D.5216>;
  <D.5216>:
  flen = flen + 1;
  D.5834 = flen + 1;
  D.5835 = (long unsigned int) D.5834;
  result = monoeg_malloc (D.5835);
  D.5836 = (sizetype) flen;
  D.5837 = result + D.5836;
  *D.5837 = 0;
  *result = 47;
  r = result + 1;
  p = uri + 8;
  goto <D.5218>;
  <D.5217>:
  D.5804 = *p;
  if (D.5804 == 37) goto <D.5838>; else goto <D.5839>;
  <D.5838>:
  r.30 = r;
  r = r.30 + 1;
  D.5809 = p + 1;
  D.5810 = *D.5809;
  D.5841 = (int) D.5810;
  D.5842 = decode (D.5841);
  D.5843 = D.5842 << 4;
  D.5844 = (char) D.5843;
  D.5812 = p + 2;
  D.5813 = *D.5812;
  D.5845 = (int) D.5813;
  D.5846 = decode (D.5845);
  D.5847 = (char) D.5846;
  D.5848 = D.5844 | D.5847;
  *r.30 = D.5848;
  p = p + 2;
  goto <D.5849>;
  <D.5839>:
  r.31 = r;
  r = r.31 + 1;
  D.5804 = *p;
  *r.31 = D.5804;
  <D.5849>:
  flen = flen + 1;
  p = p + 1;
  <D.5218>:
  D.5804 = *p;
  if (D.5804 != 0) goto <D.5217>; else goto <D.5219>;
  <D.5219>:
  D.5795 = result;
  return D.5795;
}


decode (char p)
{
  unsigned char p.32;
  unsigned char D.5853;
  int D.5856;
  int D.5857;
  unsigned char D.5858;
  unsigned char D.5861;

  p.32 = (unsigned char) p;
  D.5853 = p.32 + 208;
  if (D.5853 <= 9) goto <D.5854>; else goto <D.5855>;
  <D.5854>:
  D.5857 = (int) p;
  D.5856 = D.5857 + -48;
  return D.5856;
  <D.5855>:
  p.32 = (unsigned char) p;
  D.5858 = p.32 + 191;
  if (D.5858 <= 5) goto <D.5859>; else goto <D.5860>;
  <D.5859>:
  D.5857 = (int) p;
  D.5856 = D.5857 + -65;
  return D.5856;
  <D.5860>:
  p.32 = (unsigned char) p;
  D.5861 = p.32 + 159;
  if (D.5861 <= 5) goto <D.5862>; else goto <D.5863>;
  <D.5862>:
  D.5857 = (int) p;
  D.5856 = D.5857 + -97;
  return D.5856;
  <D.5863>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gstr.c", 618);
  D.5856 = 0;
  return D.5856;
}


monoeg_g_strdown (gchar * string)
{
  int D.5225;
  char D.5869;
  int D.5870;
  int D.5871;
  const int iftmp.33;
  unsigned int __c.34;
  unsigned int D.5876;
  const __int32_t * * D.5879;
  const __int32_t * D.5880;
  long unsigned int D.5881;
  long unsigned int D.5882;
  const __int32_t * D.5883;
  long unsigned int D.5887;
  long unsigned int D.5888;
  const __int32_t * D.5889;
  char D.5890;

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

    {
      if (0 != 0) goto <D.5867>; else goto <D.5868>;
      <D.5867>:
      D.5869 = *string;
      D.5870 = (int) D.5869;
      D.5871 = __builtin_constant_p (D.5870);
      if (D.5871 != 0) goto <D.5872>; else goto <D.5873>;
      <D.5872>:
      {
        int __c;

        D.5869 = *string;
        __c = (int) D.5869;
        __c.34 = (unsigned int) __c;
        D.5876 = __c.34 + 128;
        if (D.5876 <= 383) goto <D.5877>; else goto <D.5878>;
        <D.5877>:
        D.5879 = __ctype_tolower_loc ();
        D.5880 = *D.5879;
        D.5881 = (long unsigned int) __c;
        D.5882 = D.5881 * 4;
        D.5883 = D.5880 + D.5882;
        iftmp.33 = *D.5883;
        goto <D.5884>;
        <D.5878>:
        iftmp.33 = __c;
        <D.5884>:
        __res = iftmp.33;
      }
      goto <D.5885>;
      <D.5873>:
      D.5869 = *string;
      D.5870 = (int) D.5869;
      __res = tolower (D.5870);
      <D.5885>:
      goto <D.5886>;
      <D.5868>:
      D.5879 = __ctype_tolower_loc ();
      D.5880 = *D.5879;
      D.5869 = *string;
      D.5887 = (long unsigned int) D.5869;
      D.5888 = D.5887 * 4;
      D.5889 = D.5880 + D.5888;
      __res = *D.5889;
      <D.5886>:
    }
    D.5225 = __res;
  }
  D.5890 = (char) D.5225;
  *string = D.5890;
  string = string + 1;
  <D.5227>:
  D.5869 = *string;
  if (D.5869 != 0) goto <D.5226>; else goto <D.5228>;
  <D.5228>:
}


monoeg_g_ascii_tolower (gchar c)
{
  gchar D.5892;
  gchar iftmp.35;
  unsigned char c.36;
  unsigned char D.5895;
  unsigned char D.5898;

  c.36 = (unsigned char) c;
  D.5895 = c.36 + 191;
  if (D.5895 <= 25) goto <D.5896>; else goto <D.5897>;
  <D.5896>:
  c.36 = (unsigned char) c;
  D.5898 = c.36 + 32;
  iftmp.35 = (gchar) D.5898;
  goto <D.5899>;
  <D.5897>:
  iftmp.35 = c;
  <D.5899>:
  D.5892 = iftmp.35;
  return D.5892;
}


monoeg_g_ascii_strdown (const gchar * str, gssize len)
{
  gchar * D.5903;
  long unsigned int D.5906;
  long int D.5907;
  long unsigned int D.5908;
  sizetype D.5909;
  char * D.5910;
  const gchar * D.5911;
  char D.5912;
  int D.5913;
  char D.5914;
  long int D.5915;
  char * ret;
  int i;

  if (str == 0B) goto <D.5901>; else goto <D.5902>;
  <D.5901>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 700, "str != NULL");
  D.5903 = 0B;
  return D.5903;
  <D.5902>:
  if (len == -1) goto <D.5904>; else goto <D.5905>;
  <D.5904>:
  D.5906 = strlen (str);
  len = (gssize) D.5906;
  <D.5905>:
  D.5907 = len + 1;
  D.5908 = (long unsigned int) D.5907;
  ret = monoeg_malloc (D.5908);
  i = 0;
  goto <D.5239>;
  <D.5238>:
  D.5909 = (sizetype) i;
  D.5910 = ret + D.5909;
  D.5909 = (sizetype) i;
  D.5911 = str + D.5909;
  D.5912 = *D.5911;
  D.5913 = (int) D.5912;
  D.5914 = monoeg_g_ascii_tolower (D.5913);
  *D.5910 = D.5914;
  i = i + 1;
  <D.5239>:
  D.5915 = (long int) i;
  if (D.5915 < len) goto <D.5238>; else goto <D.5240>;
  <D.5240>:
  D.5909 = (sizetype) i;
  D.5910 = ret + D.5909;
  *D.5910 = 0;
  D.5903 = ret;
  return D.5903;
}


monoeg_ascii_toupper (gchar c)
{
  gchar D.5917;
  gchar iftmp.37;
  unsigned char c.38;
  unsigned char D.5920;
  unsigned char D.5923;

  c.38 = (unsigned char) c;
  D.5920 = c.38 + 159;
  if (D.5920 <= 25) goto <D.5921>; else goto <D.5922>;
  <D.5921>:
  c.38 = (unsigned char) c;
  D.5923 = c.38 + 224;
  iftmp.37 = (gchar) D.5923;
  goto <D.5924>;
  <D.5922>:
  iftmp.37 = c;
  <D.5924>:
  D.5917 = iftmp.37;
  return D.5917;
}


monoeg_ascii_strup (const gchar * str, gssize len)
{
  gchar * D.5928;
  long unsigned int D.5931;
  long int D.5932;
  long unsigned int D.5933;
  sizetype D.5934;
  char * D.5935;
  const gchar * D.5936;
  char D.5937;
  int D.5938;
  char D.5939;
  long int D.5940;
  char * ret;
  int i;

  if (str == 0B) goto <D.5926>; else goto <D.5927>;
  <D.5926>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 725, "str != NULL");
  D.5928 = 0B;
  return D.5928;
  <D.5927>:
  if (len == -1) goto <D.5929>; else goto <D.5930>;
  <D.5929>:
  D.5931 = strlen (str);
  len = (gssize) D.5931;
  <D.5930>:
  D.5932 = len + 1;
  D.5933 = (long unsigned int) D.5932;
  ret = monoeg_malloc (D.5933);
  i = 0;
  goto <D.5251>;
  <D.5250>:
  D.5934 = (sizetype) i;
  D.5935 = ret + D.5934;
  D.5934 = (sizetype) i;
  D.5936 = str + D.5934;
  D.5937 = *D.5936;
  D.5938 = (int) D.5937;
  D.5939 = monoeg_ascii_toupper (D.5938);
  *D.5935 = D.5939;
  i = i + 1;
  <D.5251>:
  D.5940 = (long int) i;
  if (D.5940 < len) goto <D.5250>; else goto <D.5252>;
  <D.5252>:
  D.5934 = (sizetype) i;
  D.5935 = ret + D.5934;
  *D.5935 = 0;
  D.5928 = ret;
  return D.5928;
}


monoeg_g_ascii_strncasecmp (const gchar * s1, const gchar * s2, gsize n)
{
  gint D.5944;
  const gchar * s1.39;
  char D.5948;
  int D.5949;
  const gchar * s2.40;
  char D.5951;
  int D.5952;
  int D.5955;
  int D.5956;
  gsize i;

  if (s1 == 0B) goto <D.5942>; else goto <D.5943>;
  <D.5942>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 743, "s1 != NULL");
  D.5944 = 0;
  return D.5944;
  <D.5943>:
  if (s2 == 0B) goto <D.5945>; else goto <D.5946>;
  <D.5945>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 744, "s2 != NULL");
  D.5944 = 0;
  return D.5944;
  <D.5946>:
  i = 0;
  goto <D.5262>;
  <D.5261>:
  {
    gchar c1;
    gchar c2;

    s1.39 = s1;
    s1 = s1.39 + 1;
    D.5948 = *s1.39;
    D.5949 = (int) D.5948;
    c1 = monoeg_g_ascii_tolower (D.5949);
    s2.40 = s2;
    s2 = s2.40 + 1;
    D.5951 = *s2.40;
    D.5952 = (int) D.5951;
    c2 = monoeg_g_ascii_tolower (D.5952);
    if (c1 != c2) goto <D.5953>; else goto <D.5954>;
    <D.5953>:
    D.5955 = (int) c1;
    D.5956 = (int) c2;
    D.5944 = D.5955 - D.5956;
    return D.5944;
    <D.5954>:
  }
  i = i + 1;
  <D.5262>:
  if (i < n) goto <D.5261>; else goto <D.5263>;
  <D.5263>:
  D.5944 = 0;
  return D.5944;
}


monoeg_ascii_strcasecmp (const gchar * s1, const gchar * s2)
{
  gint D.5960;
  const char * sp1.41;
  char D.5964;
  int D.5965;
  const char * sp2.42;
  char D.5967;
  int D.5968;
  int D.5971;
  int D.5972;
  char D.5973;
  int D.5974;
  char D.5975;
  int D.5976;
  const char * sp1;
  const char * sp2;

  sp1 = s1;
  sp2 = s2;
  if (s1 == 0B) goto <D.5958>; else goto <D.5959>;
  <D.5958>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 763, "s1 != NULL");
  D.5960 = 0;
  return D.5960;
  <D.5959>:
  if (s2 == 0B) goto <D.5961>; else goto <D.5962>;
  <D.5961>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 764, "s2 != NULL");
  D.5960 = 0;
  return D.5960;
  <D.5962>:
  goto <D.5273>;
  <D.5272>:
  {
    char c1;
    char c2;

    sp1.41 = sp1;
    sp1 = sp1.41 + 1;
    D.5964 = *sp1.41;
    D.5965 = (int) D.5964;
    c1 = monoeg_g_ascii_tolower (D.5965);
    sp2.42 = sp2;
    sp2 = sp2.42 + 1;
    D.5967 = *sp2.42;
    D.5968 = (int) D.5967;
    c2 = monoeg_g_ascii_tolower (D.5968);
    if (c1 != c2) goto <D.5969>; else goto <D.5970>;
    <D.5969>:
    D.5971 = (int) c1;
    D.5972 = (int) c2;
    D.5960 = D.5971 - D.5972;
    return D.5960;
    <D.5970>:
  }
  <D.5273>:
  D.5973 = *sp1;
  if (D.5973 != 0) goto <D.5272>; else goto <D.5274>;
  <D.5274>:
  D.5973 = *sp1;
  D.5974 = (int) D.5973;
  D.5975 = *sp2;
  D.5976 = (int) D.5975;
  D.5960 = D.5974 - D.5976;
  return D.5960;
}


monoeg_g_strdelimit (gchar * string, const gchar * delimiters, gchar new_delimiter)
{
  gchar * D.5980;
  _Bool iftmp.43;
  char D.5986;
  int D.5987;
  int D.5988;
  void * D.5991;
  char * D.5992;
  gchar * ptr;

  if (string == 0B) goto <D.5978>; else goto <D.5979>;
  <D.5978>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 782, "string != NULL");
  D.5980 = 0B;
  return D.5980;
  <D.5979>:
  if (delimiters == 0B) goto <D.5981>; else goto <D.5982>;
  <D.5981>:
  delimiters = "_-|> <.";
  <D.5982>:
  ptr = string;
  goto <D.5282>;
  <D.5281>:
  D.5986 = *ptr;
  D.5987 = (int) D.5986;
  D.5988 = __builtin_constant_p (D.5987);
  if (D.5988 != 0) goto <D.5989>; else goto <D.5984>;
  <D.5989>:
  D.5986 = *ptr;
  if (D.5986 == 0) goto <D.5990>; else goto <D.5984>;
  <D.5990>:
  D.5986 = *ptr;
  D.5987 = (int) D.5986;
  D.5991 = __rawmemchr (delimiters, D.5987);
  iftmp.43 = D.5991 != 0B;
  goto <D.5985>;
  <D.5984>:
  D.5986 = *ptr;
  D.5987 = (int) D.5986;
  D.5992 = __builtin_strchr (delimiters, D.5987);
  iftmp.43 = D.5992 != 0B;
  <D.5985>:
  if (iftmp.43 != 0) goto <D.5993>; else goto <D.5994>;
  <D.5993>:
  *ptr = new_delimiter;
  <D.5994>:
  ptr = ptr + 1;
  <D.5282>:
  D.5986 = *ptr;
  if (D.5986 != 0) goto <D.5281>; else goto <D.5283>;
  <D.5283>:
  D.5980 = string;
  return D.5980;
}


monoeg_g_strlcpy (gchar * dest, const gchar * src, gsize dest_size)
{
  gsize D.5998;
  const gchar * s.44;
  gchar * d.45;
  long unsigned int D.6007;
  const gchar * s.46;
  char D.6009;
  long int s.47;
  long int src.48;
  long int D.6012;
  long int D.6013;
  gchar * d;
  const gchar * s;
  gchar c;
  gsize len;

  if (src == 0B) goto <D.5996>; else goto <D.5997>;
  <D.5996>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 806, "src != NULL");
  D.5998 = 0;
  return D.5998;
  <D.5997>:
  if (dest == 0B) goto <D.5999>; else goto <D.6000>;
  <D.5999>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 807, "dest != NULL");
  D.5998 = 0;
  return D.5998;
  <D.6000>:
  len = dest_size;
  if (len == 0) goto <D.6001>; else goto <D.6002>;
  <D.6001>:
  D.5998 = 0;
  return D.5998;
  <D.6002>:
  s = src;
  d = dest;
  goto <D.5294>;
  <D.5293>:
  s.44 = s;
  s = s.44 + 1;
  c = *s.44;
  d.45 = d;
  d = d.45 + 1;
  *d.45 = c;
  if (c == 0) goto <D.6005>; else goto <D.6006>;
  <D.6005>:
  D.6007 = dest_size - len;
  D.5998 = D.6007 + 18446744073709551615;
  return D.5998;
  <D.6006>:
  <D.5294>:
  len = len + 18446744073709551615;
  if (len != 0) goto <D.5293>; else goto <D.5295>;
  <D.5295>:
  *d = 0;
  goto <D.5297>;
  <D.5296>:
  <D.5297>:
  s.46 = s;
  s = s.46 + 1;
  D.6009 = *s.46;
  if (D.6009 != 0) goto <D.5296>; else goto <D.5298>;
  <D.5298>:
  s.47 = (long int) s;
  src.48 = (long int) src;
  D.6012 = s.47 - src.48;
  D.6013 = D.6012 + -1;
  D.5998 = (gsize) D.6013;
  return D.5998;
}


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

  if (dest == 0B) goto <D.6015>; else goto <D.6016>;
  <D.6015>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 833, "dest != NULL");
  D.6017 = dest;
  return D.6017;
  <D.6016>:
  if (src == 0B) goto <D.6018>; else goto <D.6019>;
  <D.6018>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 834, "src != NULL");
  D.6017 = dest;
  return D.6017;
  <D.6019>:
  D.6017 = stpcpy (dest, src);
  return D.6017;
}


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

  D.6022 = __builtin_object_size (__dest, 1);
  D.6021 = __builtin___stpcpy_chk (__dest, __src, D.6022);
  return D.6021;
}


monoeg_g_strescape (const gchar * source, const gchar * exceptions)
{
  gchar * D.6026;
  char D.6029;
  int D.6030;
  long unsigned int D.6031;
  long unsigned int D.6032;
  long unsigned int D.6033;
  int D.6034;
  gchar * res_ptr.49;
  gchar * res_ptr.50;
  gchar * res_ptr.51;
  gchar * res_ptr.52;
  unsigned char c.53;
  unsigned char D.6046;
  unsigned char D.6047;
  char D.6048;
  gchar * res_ptr.54;
  signed char D.6050;
  unsigned char D.6051;
  unsigned char D.6052;
  unsigned char D.6053;
  char D.6054;
  gchar * res_ptr.55;
  unsigned char D.6056;
  unsigned 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.6024>; else goto <D.6025>;
      <D.6024>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstr.c", 877, "source != NULL");
      D.6026 = 0B;
      return D.6026;
      <D.6025>:
      memcpy (&escaped, &escaped_dflt, 256);
      if (exceptions != 0B) goto <D.6027>; else goto <D.6028>;
      <D.6027>:
      ptr = exceptions;
      goto <D.5315>;
      <D.5314>:
      D.6029 = *ptr;
      D.6030 = (int) D.6029;
      escaped[D.6030] = 0;
      ptr = ptr + 1;
      <D.5315>:
      D.6029 = *ptr;
      if (D.6029 != 0) goto <D.5314>; else goto <D.5316>;
      <D.5316>:
      <D.6028>:
      D.6031 = strlen (source);
      D.6032 = D.6031 * 4;
      D.6033 = D.6032 + 1;
      result = monoeg_malloc (D.6033);
      res_ptr = result;
      ptr = source;
      goto <D.5318>;
      <D.5317>:
      c = *ptr;
      D.6034 = (int) c;
      op = escaped[D.6034];
      if (op == 0) goto <D.6035>; else goto <D.6036>;
      <D.6035>:
      res_ptr.49 = res_ptr;
      res_ptr = res_ptr.49 + 1;
      *res_ptr.49 = c;
      goto <D.6038>;
      <D.6036>:
      res_ptr.50 = res_ptr;
      res_ptr = res_ptr.50 + 1;
      *res_ptr.50 = 92;
      if (op != 1) goto <D.6040>; else goto <D.6041>;
      <D.6040>:
      res_ptr.51 = res_ptr;
      res_ptr = res_ptr.51 + 1;
      *res_ptr.51 = op;
      goto <D.6043>;
      <D.6041>:
      res_ptr.52 = res_ptr;
      res_ptr = res_ptr.52 + 1;
      c.53 = (unsigned char) c;
      D.6046 = c.53 >> 6;
      D.6047 = D.6046 + 48;
      D.6048 = (char) D.6047;
      *res_ptr.52 = D.6048;
      res_ptr.54 = res_ptr;
      res_ptr = res_ptr.54 + 1;
      D.6050 = c >> 3;
      D.6051 = (unsigned char) D.6050;
      D.6052 = D.6051 & 7;
      D.6053 = D.6052 + 48;
      D.6054 = (char) D.6053;
      *res_ptr.54 = D.6054;
      res_ptr.55 = res_ptr;
      res_ptr = res_ptr.55 + 1;
      c.53 = (unsigned char) c;
      D.6056 = c.53 & 7;
      D.6057 = D.6056 + 48;
      D.6058 = (char) D.6057;
      *res_ptr.55 = D.6058;
      <D.6043>:
      <D.6038>:
      ptr = ptr + 1;
      <D.5318>:
      D.6029 = *ptr;
      if (D.6029 != 0) goto <D.5317>; else goto <D.5319>;
      <D.5319>:
      *res_ptr = 0;
      D.6026 = result;
      return D.6026;
    }
  finally
    {
      escaped = {CLOBBER};
    }
}


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.56;
  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.57;
  unsigned char c.58;
  unsigned char D.6078;
  int D.6081;
  gint iftmp.59;
  unsigned char D.6084;

  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 & 4096;
  if (D.6073 != 0) goto <D.6074>; else goto <D.6075>;
  <D.6074>:
  c.58 = (unsigned char) c;
  D.6078 = c.58 + 208;
  if (D.6078 <= 9) goto <D.6079>; else goto <D.6080>;
  <D.6079>:
  D.6081 = (int) c;
  iftmp.57 = D.6081 + -48;
  goto <D.6082>;
  <D.6080>:
  c.58 = (unsigned char) c;
  D.6084 = c.58 + 159;
  if (D.6084 <= 5) goto <D.6085>; else goto <D.6086>;
  <D.6085>:
  D.6081 = (int) c;
  iftmp.59 = D.6081 + -87;
  goto <D.6087>;
  <D.6086>:
  D.6081 = (int) c;
  iftmp.59 = D.6081 + -55;
  <D.6087>:
  iftmp.57 = iftmp.59;
  <D.6082>:
  iftmp.56 = iftmp.57;
  goto <D.6088>;
  <D.6075>:
  iftmp.56 = -1;
  <D.6088>:
  D.6064 = iftmp.56;
  return D.6064;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.6097;
  int D.6102;
  void * D.6104;
  long unsigned int D.6105;

  D.6097 = __builtin_constant_p (__len);
  if (D.6097 != 0) goto <D.6098>; else goto <D.6099>;
  <D.6098>:
  if (__len == 0) goto <D.6100>; else goto <D.6101>;
  <D.6100>:
  D.6102 = __builtin_constant_p (__ch);
  if (D.6102 == 0) goto <D.6095>; else goto <D.6103>;
  <D.6103>:
  if (__ch != 0) goto <D.6095>; else goto <D.6096>;
  <D.6095>:
  __warn_memset_zero_len ();
  D.6104 = __dest;
  return D.6104;
  <D.6096>:
  <D.6101>:
  <D.6099>:
  D.6105 = __builtin_object_size (__dest, 0);
  D.6104 = __builtin___memset_chk (__dest, __ch, __len, D.6105);
  return D.6104;
}