monoeg_g_string_new_len (const gchar * init, gssize len)
{
  size_t iftmp.0;
  unsigned int D.4655;
  unsigned int D.4656;
  unsigned int D.4657;
  unsigned int D.4658;
  void * D.4659;
  char * D.4662;
  char * D.4663;
  struct GString * D.4664;
  struct GString * ret;

  ret = monoeg_malloc (12);
  if (init == 0B) goto <D.4648>; else goto <D.4649>;
  <D.4648>:
  ret->len = 0;
  goto <D.4650>;
  <D.4649>:
  if (len < 0) goto <D.4652>; else goto <D.4653>;
  <D.4652>:
  iftmp.0 = strlen (init);
  goto <D.4654>;
  <D.4653>:
  iftmp.0 = (size_t) len;
  <D.4654>:
  ret->len = iftmp.0;
  <D.4650>:
  D.4655 = ret->len;
  D.4656 = D.4655 + 1;
  D.4657 = MAX_EXPR <D.4656, 16>;
  ret->allocated_len = D.4657;
  D.4658 = ret->allocated_len;
  D.4659 = monoeg_malloc (D.4658);
  ret->str = D.4659;
  if (init != 0B) goto <D.4660>; else goto <D.4661>;
  <D.4660>:
  D.4655 = ret->len;
  D.4662 = ret->str;
  memcpy (D.4662, init, D.4655);
  <D.4661>:
  D.4662 = ret->str;
  D.4655 = ret->len;
  D.4663 = D.4662 + D.4655;
  *D.4663 = 0;
  D.4664 = ret;
  return D.4664;
}


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

  D.4667 = __builtin_object_size (__dest, 0);
  D.4666 = __builtin___memcpy_chk (__dest, __src, __len, D.4667);
  return D.4666;
}


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

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


monoeg_g_string_sized_new (gsize default_size)
{
  void * D.4671;
  char * D.4672;
  struct GString * D.4673;
  struct GString * ret;

  ret = monoeg_malloc (12);
  D.4671 = monoeg_malloc (default_size);
  ret->str = D.4671;
  D.4672 = ret->str;
  *D.4672 = 0;
  ret->len = 0;
  ret->allocated_len = default_size;
  D.4673 = ret;
  return D.4673;
}


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

  if (string == 0B) goto <D.4675>; else goto <D.4676>;
  <D.4675>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 81, "string != NULL");
  D.4677 = 0B;
  return D.4677;
  <D.4676>:
  data = string->str;
  monoeg_g_free (string);
  if (free_segment == 0) goto <D.4678>; else goto <D.4679>;
  <D.4678>:
  D.4677 = data;
  return D.4677;
  <D.4679>:
  monoeg_g_free (data);
  D.4677 = 0B;
  return D.4677;
}


monoeg_g_string_append_len (struct GString * string, const gchar * val, gssize len)
{
  struct GString * D.4683;
  unsigned int D.4688;
  unsigned int D.4689;
  unsigned int len.1;
  unsigned int D.4691;
  unsigned int D.4692;
  unsigned int D.4695;
  unsigned int D.4696;
  unsigned int D.4697;
  char * D.4698;
  void * D.4699;
  unsigned int len.2;
  char * D.4701;

  if (string == 0B) goto <D.4681>; else goto <D.4682>;
  <D.4681>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 97, "string != NULL");
  D.4683 = 0B;
  return D.4683;
  <D.4682>:
  if (val == 0B) goto <D.4684>; else goto <D.4685>;
  <D.4684>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 98, "val != NULL");
  D.4683 = string;
  return D.4683;
  <D.4685>:
  if (len < 0) goto <D.4686>; else goto <D.4687>;
  <D.4686>:
  D.4688 = strlen (val);
  len = (gssize) D.4688;
  <D.4687>:
  D.4689 = string->len;
  len.1 = (unsigned int) len;
  D.4691 = D.4689 + len.1;
  D.4692 = string->allocated_len;
  if (D.4691 >= D.4692) goto <D.4693>; else goto <D.4694>;
  <D.4693>:
  D.4692 = string->allocated_len;
  len.1 = (unsigned int) len;
  D.4695 = D.4692 + len.1;
  D.4696 = D.4695 + 16;
  D.4697 = D.4696 * 2;
  string->allocated_len = D.4697;
  D.4692 = string->allocated_len;
  D.4698 = string->str;
  D.4699 = monoeg_realloc (D.4698, D.4692);
  string->str = D.4699;
  <D.4694>:
  len.2 = (unsigned int) len;
  D.4698 = string->str;
  D.4689 = string->len;
  D.4701 = D.4698 + D.4689;
  memcpy (D.4701, val, len.2);
  D.4689 = string->len;
  len.1 = (unsigned int) len;
  D.4691 = D.4689 + len.1;
  string->len = D.4691;
  D.4698 = string->str;
  D.4689 = string->len;
  D.4701 = D.4698 + D.4689;
  *D.4701 = 0;
  D.4683 = string;
  return D.4683;
}


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

  if (string == 0B) goto <D.4703>; else goto <D.4704>;
  <D.4703>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 115, "string != NULL");
  D.4705 = 0B;
  return D.4705;
  <D.4704>:
  if (val == 0B) goto <D.4706>; else goto <D.4707>;
  <D.4706>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 116, "val != NULL");
  D.4705 = string;
  return D.4705;
  <D.4707>:
  D.4705 = monoeg_g_string_append_len (string, val, -1);
  return D.4705;
}


monoeg_g_string_append_c (struct GString * string, gchar c)
{
  struct GString * D.4711;
  unsigned int D.4712;
  unsigned int D.4713;
  unsigned int D.4714;
  unsigned int D.4717;
  unsigned int D.4718;
  char * D.4719;
  void * D.4720;
  char * D.4721;
  sizetype D.4722;
  char * D.4723;

  if (string == 0B) goto <D.4709>; else goto <D.4710>;
  <D.4709>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 124, "string != NULL");
  D.4711 = 0B;
  return D.4711;
  <D.4710>:
  D.4712 = string->len;
  D.4713 = D.4712 + 1;
  D.4714 = string->allocated_len;
  if (D.4713 >= D.4714) goto <D.4715>; else goto <D.4716>;
  <D.4715>:
  D.4714 = string->allocated_len;
  D.4717 = D.4714 + 17;
  D.4718 = D.4717 * 2;
  string->allocated_len = D.4718;
  D.4714 = string->allocated_len;
  D.4719 = string->str;
  D.4720 = monoeg_realloc (D.4719, D.4714);
  string->str = D.4720;
  <D.4716>:
  D.4719 = string->str;
  D.4712 = string->len;
  D.4721 = D.4719 + D.4712;
  *D.4721 = c;
  D.4719 = string->str;
  D.4712 = string->len;
  D.4722 = D.4712 + 1;
  D.4723 = D.4719 + D.4722;
  *D.4723 = 0;
  D.4712 = string->len;
  D.4713 = D.4712 + 1;
  string->len = D.4713;
  D.4711 = string;
  return D.4711;
}


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

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


monoeg_g_string_prepend (struct GString * string, const gchar * val)
{
  struct GString * D.4734;
  unsigned int D.4737;
  unsigned int D.4738;
  unsigned int len.3;
  unsigned int D.4740;
  unsigned int D.4741;
  unsigned int D.4744;
  unsigned int D.4745;
  unsigned int D.4746;
  char * D.4747;
  void * D.4748;
  unsigned int D.4749;
  sizetype len.4;
  void * D.4751;
  unsigned int len.5;
  gssize len;

  if (string == 0B) goto <D.4732>; else goto <D.4733>;
  <D.4732>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 154, "string != NULL");
  D.4734 = string;
  return D.4734;
  <D.4733>:
  if (val == 0B) goto <D.4735>; else goto <D.4736>;
  <D.4735>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 155, "val != NULL");
  D.4734 = string;
  return D.4734;
  <D.4736>:
  D.4737 = strlen (val);
  len = (gssize) D.4737;
  D.4738 = string->len;
  len.3 = (unsigned int) len;
  D.4740 = D.4738 + len.3;
  D.4741 = string->allocated_len;
  if (D.4740 >= D.4741) goto <D.4742>; else goto <D.4743>;
  <D.4742>:
  D.4741 = string->allocated_len;
  len.3 = (unsigned int) len;
  D.4744 = D.4741 + len.3;
  D.4745 = D.4744 + 16;
  D.4746 = D.4745 * 2;
  string->allocated_len = D.4746;
  D.4741 = string->allocated_len;
  D.4747 = string->str;
  D.4748 = monoeg_realloc (D.4747, D.4741);
  string->str = D.4748;
  <D.4743>:
  D.4738 = string->len;
  D.4749 = D.4738 + 1;
  D.4747 = string->str;
  D.4747 = string->str;
  len.4 = (sizetype) len;
  D.4751 = D.4747 + len.4;
  memmove (D.4751, D.4747, D.4749);
  len.5 = (unsigned int) len;
  D.4747 = string->str;
  memcpy (D.4747, val, len.5);
  D.4734 = string;
  return D.4734;
}


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

  D.4755 = __builtin_object_size (__dest, 0);
  D.4754 = __builtin___memmove_chk (__dest, __src, __len, D.4755);
  return D.4754;
}


monoeg_g_string_insert (struct GString * string, gssize pos, const gchar * val)
{
  struct GString * D.4759;
  unsigned int pos.6;
  unsigned int D.4763;
  unsigned int D.4766;
  unsigned int len.7;
  unsigned int D.4768;
  unsigned int D.4769;
  unsigned int D.4772;
  unsigned int D.4773;
  unsigned int D.4774;
  char * D.4775;
  void * D.4776;
  unsigned int D.4777;
  unsigned int D.4778;
  unsigned int D.4779;
  sizetype pos.8;
  const void * D.4781;
  sizetype len.9;
  sizetype D.4783;
  char * D.4784;
  unsigned int len.10;
  char * D.4786;
  gssize len;

  if (string == 0B) goto <D.4757>; else goto <D.4758>;
  <D.4757>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 171, "string != NULL");
  D.4759 = string;
  return D.4759;
  <D.4758>:
  if (val == 0B) goto <D.4760>; else goto <D.4761>;
  <D.4760>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 172, "val != NULL");
  D.4759 = string;
  return D.4759;
  <D.4761>:
  pos.6 = (unsigned int) pos;
  D.4763 = string->len;
  if (pos.6 > D.4763) goto <D.4764>; else goto <D.4765>;
  <D.4764>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 173, "pos <= string->len");
  D.4759 = string;
  return D.4759;
  <D.4765>:
  D.4766 = strlen (val);
  len = (gssize) D.4766;
  D.4763 = string->len;
  len.7 = (unsigned int) len;
  D.4768 = D.4763 + len.7;
  D.4769 = string->allocated_len;
  if (D.4768 >= D.4769) goto <D.4770>; else goto <D.4771>;
  <D.4770>:
  D.4769 = string->allocated_len;
  len.7 = (unsigned int) len;
  D.4772 = D.4769 + len.7;
  D.4773 = D.4772 + 16;
  D.4774 = D.4773 * 2;
  string->allocated_len = D.4774;
  D.4769 = string->allocated_len;
  D.4775 = string->str;
  D.4776 = monoeg_realloc (D.4775, D.4769);
  string->str = D.4776;
  <D.4771>:
  D.4763 = string->len;
  pos.6 = (unsigned int) pos;
  D.4777 = D.4763 - pos.6;
  len.7 = (unsigned int) len;
  D.4778 = D.4777 - len.7;
  D.4779 = D.4778 + 1;
  D.4775 = string->str;
  pos.8 = (sizetype) pos;
  D.4781 = D.4775 + pos.8;
  D.4775 = string->str;
  pos.8 = (sizetype) pos;
  len.9 = (sizetype) len;
  D.4783 = pos.8 + len.9;
  D.4784 = D.4775 + D.4783;
  memmove (D.4784, D.4781, D.4779);
  len.10 = (unsigned int) len;
  D.4775 = string->str;
  pos.8 = (sizetype) pos;
  D.4786 = D.4775 + pos.8;
  memcpy (D.4786, val, len.10);
  D.4759 = string;
  return D.4759;
}


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

  try
    {
      if (string == 0B) goto <D.4788>; else goto <D.4789>;
      <D.4788>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 190, "string != NULL");
      return;
      <D.4789>:
      if (format == 0B) goto <D.4790>; else goto <D.4791>;
      <D.4790>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 191, "format != NULL");
      return;
      <D.4791>:
      __builtin_va_start (&args, 0);
      args.11 = args;
      ret = monoeg_g_strdup_vprintf (format, args.11);
      __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, char * args)
{
  char * ret;

  if (string == 0B) goto <D.4796>; else goto <D.4797>;
  <D.4796>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 206, "string != NULL");
  return;
  <D.4797>:
  if (format == 0B) goto <D.4798>; else goto <D.4799>;
  <D.4798>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 207, "format != NULL");
  return;
  <D.4799>:
  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.4805;
  char * args.12;
  gchar * D.4807;
  unsigned int D.4808;
  unsigned int D.4809;
  unsigned int D.4810;
  char * args;

  try
    {
      if (string == 0B) goto <D.4801>; else goto <D.4802>;
      <D.4801>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 219, "string != NULL");
      return;
      <D.4802>:
      if (format == 0B) goto <D.4803>; else goto <D.4804>;
      <D.4803>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 220, "format != NULL");
      return;
      <D.4804>:
      D.4805 = string->str;
      monoeg_g_free (D.4805);
      __builtin_va_start (&args, 0);
      args.12 = args;
      D.4807 = monoeg_g_strdup_vprintf (format, args.12);
      string->str = D.4807;
      __builtin_va_end (&args);
      D.4805 = string->str;
      D.4808 = strlen (D.4805);
      string->len = D.4808;
      D.4809 = string->len;
      D.4810 = D.4809 + 1;
      string->allocated_len = D.4810;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_string_truncate (struct GString * string, gsize len)
{
  struct GString * D.4816;
  unsigned int D.4817;
  char * D.4820;
  char * D.4821;

  if (string == 0B) goto <D.4814>; else goto <D.4815>;
  <D.4814>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 235, "string != NULL");
  D.4816 = string;
  return D.4816;
  <D.4815>:
  D.4817 = string->len;
  if (D.4817 <= len) goto <D.4818>; else goto <D.4819>;
  <D.4818>:
  D.4816 = string;
  return D.4816;
  <D.4819>:
  string->len = len;
  D.4820 = string->str;
  D.4821 = D.4820 + len;
  *D.4821 = 0;
  D.4816 = string;
  return D.4816;
}


monoeg_g_string_set_size (struct GString * string, gsize len)
{
  struct GString * D.4825;
  unsigned int D.4826;
  unsigned int D.4827;
  unsigned int D.4828;
  unsigned int D.4831;
  unsigned int D.4832;
  unsigned int D.4833;
  char * D.4834;
  void * D.4835;
  char * D.4836;

  if (string == 0B) goto <D.4823>; else goto <D.4824>;
  <D.4823>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 249, "string != NULL");
  D.4825 = string;
  return D.4825;
  <D.4824>:
  D.4826 = string->len;
  D.4827 = D.4826 + len;
  D.4828 = string->allocated_len;
  if (D.4827 >= D.4828) goto <D.4829>; else goto <D.4830>;
  <D.4829>:
  D.4828 = string->allocated_len;
  D.4831 = D.4828 + len;
  D.4832 = D.4831 + 16;
  D.4833 = D.4832 * 2;
  string->allocated_len = D.4833;
  D.4828 = string->allocated_len;
  D.4834 = string->str;
  D.4835 = monoeg_realloc (D.4834, D.4828);
  string->str = D.4835;
  <D.4830>:
  string->len = len;
  D.4834 = string->str;
  D.4836 = D.4834 + len;
  *D.4836 = 0;
  D.4825 = string;
  return D.4825;
}


monoeg_g_string_erase (struct GString * string, gssize pos, gssize len)
{
  struct GString * D.4840;
  unsigned int pos.13;
  unsigned int D.4842;
  int D.4849;
  unsigned int D.4850;
  char * D.4851;
  sizetype pos.14;
  char * D.4853;
  unsigned int D.4854;
  unsigned int D.4855;
  sizetype len.15;
  sizetype D.4857;
  char * D.4858;
  void * D.4859;
  unsigned int len.16;
  unsigned int D.4861;

  if (string == 0B) goto <D.4838>; else goto <D.4839>;
  <D.4838>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 261, "string != NULL");
  D.4840 = string;
  return D.4840;
  <D.4839>:
  pos.13 = (unsigned int) pos;
  D.4842 = string->len;
  if (pos.13 >= D.4842) goto <D.4843>; else goto <D.4844>;
  <D.4843>:
  D.4840 = string;
  return D.4840;
  <D.4844>:
  if (len == -1) goto <D.4845>; else goto <D.4848>;
  <D.4848>:
  D.4849 = pos + len;
  D.4850 = (unsigned int) D.4849;
  D.4842 = string->len;
  if (D.4850 >= D.4842) goto <D.4845>; else goto <D.4846>;
  <D.4845>:
  D.4851 = string->str;
  pos.14 = (sizetype) pos;
  D.4853 = D.4851 + pos.14;
  *D.4853 = 0;
  goto <D.4847>;
  <D.4846>:
  D.4842 = string->len;
  D.4849 = pos + len;
  D.4850 = (unsigned int) D.4849;
  D.4854 = D.4842 - D.4850;
  D.4855 = D.4854 + 1;
  D.4851 = string->str;
  pos.14 = (sizetype) pos;
  len.15 = (sizetype) len;
  D.4857 = pos.14 + len.15;
  D.4858 = D.4851 + D.4857;
  D.4851 = string->str;
  pos.14 = (sizetype) pos;
  D.4859 = D.4851 + pos.14;
  memmove (D.4859, D.4858, D.4855);
  D.4842 = string->len;
  len.16 = (unsigned int) len;
  D.4861 = D.4842 - len.16;
  string->len = D.4861;
  <D.4847>:
  D.4840 = string;
  return D.4840;
}