monoeg_g_string_new_len (const gchar * init, gssize len)
{
  size_t iftmp.0;
  unsigned int D.7264;
  unsigned int D.7265;
  unsigned int D.7266;
  unsigned int D.7267;
  void * D.7268;
  char * D.7271;
  char * D.7272;
  struct GString * D.7273;
  struct GString * ret;

  ret = monoeg_malloc (12);
  if (init == 0B) goto <D.7257>; else goto <D.7258>;
  <D.7257>:
  ret->len = 0;
  goto <D.7259>;
  <D.7258>:
  if (len < 0) goto <D.7261>; else goto <D.7262>;
  <D.7261>:
  iftmp.0 = strlen (init);
  goto <D.7263>;
  <D.7262>:
  iftmp.0 = (size_t) len;
  <D.7263>:
  ret->len = iftmp.0;
  <D.7259>:
  D.7264 = ret->len;
  D.7265 = D.7264 + 1;
  D.7266 = MAX_EXPR <D.7265, 16>;
  ret->allocated_len = D.7266;
  D.7267 = ret->allocated_len;
  D.7268 = monoeg_malloc (D.7267);
  ret->str = D.7268;
  if (init != 0B) goto <D.7269>; else goto <D.7270>;
  <D.7269>:
  D.7271 = ret->str;
  D.7264 = ret->len;
  memcpy (D.7271, init, D.7264);
  <D.7270>:
  D.7271 = ret->str;
  D.7264 = ret->len;
  D.7272 = D.7271 + D.7264;
  *D.7272 = 0;
  D.7273 = ret;
  return D.7273;
}


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

  D.7276 = __builtin_object_size (__dest, 0);
  D.7275 = __builtin___memcpy_chk (__dest, __src, __len, D.7276);
  return D.7275;
}


monoeg_g_string_new (const gchar * init)
{
  struct GString * D.7278;

  D.7278 = monoeg_g_string_new_len (init, -1);
  return D.7278;
}


monoeg_g_string_sized_new (gsize default_size)
{
  void * D.7280;
  char * D.7281;
  struct GString * D.7282;
  struct GString * ret;

  ret = monoeg_malloc (12);
  D.7280 = monoeg_malloc (default_size);
  ret->str = D.7280;
  D.7281 = ret->str;
  *D.7281 = 0;
  ret->len = 0;
  ret->allocated_len = default_size;
  D.7282 = ret;
  return D.7282;
}


monoeg_g_string_free (struct GString * string, gboolean free_segment)
{
  gchar * D.7286;
  gchar * data;

  if (string == 0B) goto <D.7284>; else goto <D.7285>;
  <D.7284>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 81, "string != NULL");
  D.7286 = 0B;
  return D.7286;
  <D.7285>:
  data = string->str;
  monoeg_g_free (string);
  if (free_segment == 0) goto <D.7287>; else goto <D.7288>;
  <D.7287>:
  D.7286 = data;
  return D.7286;
  <D.7288>:
  monoeg_g_free (data);
  D.7286 = 0B;
  return D.7286;
}


monoeg_g_string_append_len (struct GString * string, const gchar * val, gssize len)
{
  struct GString * D.7292;
  unsigned int D.7297;
  unsigned int D.7298;
  unsigned int len.1;
  unsigned int D.7300;
  unsigned int D.7301;
  unsigned int D.7304;
  unsigned int D.7305;
  unsigned int D.7306;
  char * D.7307;
  void * D.7308;
  char * D.7309;
  unsigned int len.2;

  if (string == 0B) goto <D.7290>; else goto <D.7291>;
  <D.7290>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 97, "string != NULL");
  D.7292 = 0B;
  return D.7292;
  <D.7291>:
  if (val == 0B) goto <D.7293>; else goto <D.7294>;
  <D.7293>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 98, "val != NULL");
  D.7292 = string;
  return D.7292;
  <D.7294>:
  if (len < 0) goto <D.7295>; else goto <D.7296>;
  <D.7295>:
  D.7297 = strlen (val);
  len = (gssize) D.7297;
  <D.7296>:
  D.7298 = string->len;
  len.1 = (unsigned int) len;
  D.7300 = D.7298 + len.1;
  D.7301 = string->allocated_len;
  if (D.7300 >= D.7301) goto <D.7302>; else goto <D.7303>;
  <D.7302>:
  D.7301 = string->allocated_len;
  len.1 = (unsigned int) len;
  D.7304 = D.7301 + len.1;
  D.7305 = D.7304 + 16;
  D.7306 = D.7305 * 2;
  string->allocated_len = D.7306;
  D.7307 = string->str;
  D.7301 = string->allocated_len;
  D.7308 = monoeg_realloc (D.7307, D.7301);
  string->str = D.7308;
  <D.7303>:
  D.7307 = string->str;
  D.7298 = string->len;
  D.7309 = D.7307 + D.7298;
  len.2 = (unsigned int) len;
  memcpy (D.7309, val, len.2);
  D.7298 = string->len;
  len.1 = (unsigned int) len;
  D.7300 = D.7298 + len.1;
  string->len = D.7300;
  D.7307 = string->str;
  D.7298 = string->len;
  D.7309 = D.7307 + D.7298;
  *D.7309 = 0;
  D.7292 = string;
  return D.7292;
}


monoeg_g_string_append (struct GString * string, const gchar * val)
{
  struct GString * D.7314;

  if (string == 0B) goto <D.7312>; else goto <D.7313>;
  <D.7312>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 115, "string != NULL");
  D.7314 = 0B;
  return D.7314;
  <D.7313>:
  if (val == 0B) goto <D.7315>; else goto <D.7316>;
  <D.7315>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 116, "val != NULL");
  D.7314 = string;
  return D.7314;
  <D.7316>:
  D.7314 = monoeg_g_string_append_len (string, val, -1);
  return D.7314;
}


monoeg_g_string_append_c (struct GString * string, gchar c)
{
  struct GString * D.7320;
  unsigned int D.7321;
  unsigned int D.7322;
  unsigned int D.7323;
  unsigned int D.7326;
  unsigned int D.7327;
  char * D.7328;
  void * D.7329;
  char * D.7330;
  sizetype D.7331;
  char * D.7332;

  if (string == 0B) goto <D.7318>; else goto <D.7319>;
  <D.7318>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 124, "string != NULL");
  D.7320 = 0B;
  return D.7320;
  <D.7319>:
  D.7321 = string->len;
  D.7322 = D.7321 + 1;
  D.7323 = string->allocated_len;
  if (D.7322 >= D.7323) goto <D.7324>; else goto <D.7325>;
  <D.7324>:
  D.7323 = string->allocated_len;
  D.7326 = D.7323 + 17;
  D.7327 = D.7326 * 2;
  string->allocated_len = D.7327;
  D.7328 = string->str;
  D.7323 = string->allocated_len;
  D.7329 = monoeg_realloc (D.7328, D.7323);
  string->str = D.7329;
  <D.7325>:
  D.7328 = string->str;
  D.7321 = string->len;
  D.7330 = D.7328 + D.7321;
  *D.7330 = c;
  D.7328 = string->str;
  D.7321 = string->len;
  D.7331 = D.7321 + 1;
  D.7332 = D.7328 + D.7331;
  *D.7332 = 0;
  D.7321 = string->len;
  D.7322 = D.7321 + 1;
  string->len = D.7322;
  D.7320 = string;
  return D.7320;
}


monoeg_g_string_append_unichar (struct GString * string, gunichar c)
{
  struct GString * D.7336;
  gchar utf8[6];
  gint len;

  try
    {
      if (string == 0B) goto <D.7334>; else goto <D.7335>;
      <D.7334>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 141, "string != NULL");
      D.7336 = 0B;
      return D.7336;
      <D.7335>:
      len = monoeg_g_unichar_to_utf8 (c, &utf8);
      if (len <= 0) goto <D.7337>; else goto <D.7338>;
      <D.7337>:
      D.7336 = string;
      return D.7336;
      <D.7338>:
      D.7336 = monoeg_g_string_append_len (string, &utf8, len);
      return D.7336;
    }
  finally
    {
      utf8 = {CLOBBER};
    }
}


monoeg_g_string_prepend (struct GString * string, const gchar * val)
{
  struct GString * D.7343;
  unsigned int D.7346;
  unsigned int D.7347;
  unsigned int len.3;
  unsigned int D.7349;
  unsigned int D.7350;
  unsigned int D.7353;
  unsigned int D.7354;
  unsigned int D.7355;
  char * D.7356;
  void * D.7357;
  sizetype len.4;
  void * D.7359;
  unsigned int D.7360;
  unsigned int len.5;
  gssize len;

  if (string == 0B) goto <D.7341>; else goto <D.7342>;
  <D.7341>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 154, "string != NULL");
  D.7343 = string;
  return D.7343;
  <D.7342>:
  if (val == 0B) goto <D.7344>; else goto <D.7345>;
  <D.7344>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 155, "val != NULL");
  D.7343 = string;
  return D.7343;
  <D.7345>:
  D.7346 = strlen (val);
  len = (gssize) D.7346;
  D.7347 = string->len;
  len.3 = (unsigned int) len;
  D.7349 = D.7347 + len.3;
  D.7350 = string->allocated_len;
  if (D.7349 >= D.7350) goto <D.7351>; else goto <D.7352>;
  <D.7351>:
  D.7350 = string->allocated_len;
  len.3 = (unsigned int) len;
  D.7353 = D.7350 + len.3;
  D.7354 = D.7353 + 16;
  D.7355 = D.7354 * 2;
  string->allocated_len = D.7355;
  D.7356 = string->str;
  D.7350 = string->allocated_len;
  D.7357 = monoeg_realloc (D.7356, D.7350);
  string->str = D.7357;
  <D.7352>:
  D.7356 = string->str;
  len.4 = (sizetype) len;
  D.7359 = D.7356 + len.4;
  D.7356 = string->str;
  D.7347 = string->len;
  D.7360 = D.7347 + 1;
  memmove (D.7359, D.7356, D.7360);
  D.7356 = string->str;
  len.5 = (unsigned int) len;
  memcpy (D.7356, val, len.5);
  D.7343 = string;
  return D.7343;
}


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

  D.7364 = __builtin_object_size (__dest, 0);
  D.7363 = __builtin___memmove_chk (__dest, __src, __len, D.7364);
  return D.7363;
}


monoeg_g_string_insert (struct GString * string, gssize pos, const gchar * val)
{
  struct GString * D.7368;
  unsigned int pos.6;
  unsigned int D.7372;
  unsigned int D.7375;
  unsigned int len.7;
  unsigned int D.7377;
  unsigned int D.7378;
  unsigned int D.7381;
  unsigned int D.7382;
  unsigned int D.7383;
  char * D.7384;
  void * D.7385;
  sizetype pos.8;
  sizetype len.9;
  sizetype D.7388;
  char * D.7389;
  const void * D.7390;
  unsigned int D.7391;
  unsigned int D.7392;
  unsigned int D.7393;
  char * D.7394;
  unsigned int len.10;
  gssize len;

  if (string == 0B) goto <D.7366>; else goto <D.7367>;
  <D.7366>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 171, "string != NULL");
  D.7368 = string;
  return D.7368;
  <D.7367>:
  if (val == 0B) goto <D.7369>; else goto <D.7370>;
  <D.7369>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 172, "val != NULL");
  D.7368 = string;
  return D.7368;
  <D.7370>:
  pos.6 = (unsigned int) pos;
  D.7372 = string->len;
  if (pos.6 > D.7372) goto <D.7373>; else goto <D.7374>;
  <D.7373>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 173, "pos <= string->len");
  D.7368 = string;
  return D.7368;
  <D.7374>:
  D.7375 = strlen (val);
  len = (gssize) D.7375;
  D.7372 = string->len;
  len.7 = (unsigned int) len;
  D.7377 = D.7372 + len.7;
  D.7378 = string->allocated_len;
  if (D.7377 >= D.7378) goto <D.7379>; else goto <D.7380>;
  <D.7379>:
  D.7378 = string->allocated_len;
  len.7 = (unsigned int) len;
  D.7381 = D.7378 + len.7;
  D.7382 = D.7381 + 16;
  D.7383 = D.7382 * 2;
  string->allocated_len = D.7383;
  D.7384 = string->str;
  D.7378 = string->allocated_len;
  D.7385 = monoeg_realloc (D.7384, D.7378);
  string->str = D.7385;
  <D.7380>:
  D.7384 = string->str;
  pos.8 = (sizetype) pos;
  len.9 = (sizetype) len;
  D.7388 = pos.8 + len.9;
  D.7389 = D.7384 + D.7388;
  D.7384 = string->str;
  pos.8 = (sizetype) pos;
  D.7390 = D.7384 + pos.8;
  D.7372 = string->len;
  pos.6 = (unsigned int) pos;
  D.7391 = D.7372 - pos.6;
  len.7 = (unsigned int) len;
  D.7392 = D.7391 - len.7;
  D.7393 = D.7392 + 1;
  memmove (D.7389, D.7390, D.7393);
  D.7384 = string->str;
  pos.8 = (sizetype) pos;
  D.7394 = D.7384 + pos.8;
  len.10 = (unsigned int) len;
  memcpy (D.7394, val, len.10);
  D.7368 = string;
  return D.7368;
}


monoeg_g_string_append_printf (struct GString * string, const gchar * format)
{
  char * ret;
  struct va_list args;

  try
    {
      if (string == 0B) goto <D.7397>; else goto <D.7398>;
      <D.7397>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 190, "string != NULL");
      return;
      <D.7398>:
      if (format == 0B) goto <D.7399>; else goto <D.7400>;
      <D.7399>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 191, "format != NULL");
      return;
      <D.7400>:
      __builtin_va_start (&args, 0);
      ret = monoeg_g_strdup_vprintf (format, args);
      __builtin_va_end (&args);
      monoeg_g_string_append (string, ret);
      monoeg_g_free (ret);
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_string_append_vprintf (struct GString * string, const gchar * format, struct va_list args)
{
  char * ret;

  if (string == 0B) goto <D.7404>; else goto <D.7405>;
  <D.7404>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 206, "string != NULL");
  return;
  <D.7405>:
  if (format == 0B) goto <D.7406>; else goto <D.7407>;
  <D.7406>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 207, "format != NULL");
  return;
  <D.7407>:
  ret = monoeg_g_strdup_vprintf (format, args);
  monoeg_g_string_append (string, ret);
  monoeg_g_free (ret);
}


monoeg_g_string_printf (struct GString * string, const gchar * format)
{
  char * D.7413;
  gchar * D.7414;
  unsigned int D.7415;
  unsigned int D.7416;
  unsigned int D.7417;
  struct va_list args;

  try
    {
      if (string == 0B) goto <D.7409>; else goto <D.7410>;
      <D.7409>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 219, "string != NULL");
      return;
      <D.7410>:
      if (format == 0B) goto <D.7411>; else goto <D.7412>;
      <D.7411>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 220, "format != NULL");
      return;
      <D.7412>:
      D.7413 = string->str;
      monoeg_g_free (D.7413);
      __builtin_va_start (&args, 0);
      D.7414 = monoeg_g_strdup_vprintf (format, args);
      string->str = D.7414;
      __builtin_va_end (&args);
      D.7413 = string->str;
      D.7415 = strlen (D.7413);
      string->len = D.7415;
      D.7416 = string->len;
      D.7417 = D.7416 + 1;
      string->allocated_len = D.7417;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_string_truncate (struct GString * string, gsize len)
{
  struct GString * D.7423;
  unsigned int D.7424;
  char * D.7427;
  char * D.7428;

  if (string == 0B) goto <D.7421>; else goto <D.7422>;
  <D.7421>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 235, "string != NULL");
  D.7423 = string;
  return D.7423;
  <D.7422>:
  D.7424 = string->len;
  if (D.7424 <= len) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  D.7423 = string;
  return D.7423;
  <D.7426>:
  string->len = len;
  D.7427 = string->str;
  D.7428 = D.7427 + len;
  *D.7428 = 0;
  D.7423 = string;
  return D.7423;
}


monoeg_g_string_set_size (struct GString * string, gsize len)
{
  struct GString * D.7432;
  unsigned int D.7433;
  unsigned int D.7434;
  unsigned int D.7435;
  unsigned int D.7438;
  unsigned int D.7439;
  unsigned int D.7440;
  char * D.7441;
  void * D.7442;
  char * D.7443;

  if (string == 0B) goto <D.7430>; else goto <D.7431>;
  <D.7430>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 249, "string != NULL");
  D.7432 = string;
  return D.7432;
  <D.7431>:
  D.7433 = string->len;
  D.7434 = D.7433 + len;
  D.7435 = string->allocated_len;
  if (D.7434 >= D.7435) goto <D.7436>; else goto <D.7437>;
  <D.7436>:
  D.7435 = string->allocated_len;
  D.7438 = D.7435 + len;
  D.7439 = D.7438 + 16;
  D.7440 = D.7439 * 2;
  string->allocated_len = D.7440;
  D.7441 = string->str;
  D.7435 = string->allocated_len;
  D.7442 = monoeg_realloc (D.7441, D.7435);
  string->str = D.7442;
  <D.7437>:
  string->len = len;
  D.7441 = string->str;
  D.7443 = D.7441 + len;
  *D.7443 = 0;
  D.7432 = string;
  return D.7432;
}


monoeg_g_string_erase (struct GString * string, gssize pos, gssize len)
{
  struct GString * D.7447;
  unsigned int pos.11;
  unsigned int D.7449;
  int D.7456;
  unsigned int D.7457;
  char * D.7458;
  sizetype pos.12;
  char * D.7460;
  void * D.7461;
  sizetype len.13;
  sizetype D.7463;
  char * D.7464;
  unsigned int D.7465;
  unsigned int D.7466;
  unsigned int len.14;
  unsigned int D.7468;

  if (string == 0B) goto <D.7445>; else goto <D.7446>;
  <D.7445>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 261, "string != NULL");
  D.7447 = string;
  return D.7447;
  <D.7446>:
  pos.11 = (unsigned int) pos;
  D.7449 = string->len;
  if (pos.11 >= D.7449) goto <D.7450>; else goto <D.7451>;
  <D.7450>:
  D.7447 = string;
  return D.7447;
  <D.7451>:
  if (len == -1) goto <D.7452>; else goto <D.7455>;
  <D.7455>:
  D.7456 = pos + len;
  D.7457 = (unsigned int) D.7456;
  D.7449 = string->len;
  if (D.7457 >= D.7449) goto <D.7452>; else goto <D.7453>;
  <D.7452>:
  D.7458 = string->str;
  pos.12 = (sizetype) pos;
  D.7460 = D.7458 + pos.12;
  *D.7460 = 0;
  goto <D.7454>;
  <D.7453>:
  D.7458 = string->str;
  pos.12 = (sizetype) pos;
  D.7461 = D.7458 + pos.12;
  D.7458 = string->str;
  pos.12 = (sizetype) pos;
  len.13 = (sizetype) len;
  D.7463 = pos.12 + len.13;
  D.7464 = D.7458 + D.7463;
  D.7449 = string->len;
  D.7456 = pos + len;
  D.7457 = (unsigned int) D.7456;
  D.7465 = D.7449 - D.7457;
  D.7466 = D.7465 + 1;
  memmove (D.7461, D.7464, D.7466);
  D.7449 = string->len;
  len.14 = (unsigned int) len;
  D.7468 = D.7449 - len.14;
  string->len = D.7468;
  <D.7454>:
  D.7447 = string;
  return D.7447;
}