monoeg_g_string_new_len (const gchar * init, gssize len)
{
  size_t iftmp.0;
  unsigned int D.4675;
  unsigned int D.4676;
  unsigned int D.4677;
  unsigned int D.4678;
  void * D.4679;
  char * D.4682;
  char * D.4683;
  struct GString * D.4684;
  struct GString * ret;

  ret = monoeg_malloc (12);
  if (init == 0B) goto <D.4668>; else goto <D.4669>;
  <D.4668>:
  ret->len = 0;
  goto <D.4670>;
  <D.4669>:
  if (len < 0) goto <D.4672>; else goto <D.4673>;
  <D.4672>:
  iftmp.0 = strlen (init);
  goto <D.4674>;
  <D.4673>:
  iftmp.0 = (size_t) len;
  <D.4674>:
  ret->len = iftmp.0;
  <D.4670>:
  D.4675 = ret->len;
  D.4676 = D.4675 + 1;
  D.4677 = MAX_EXPR <D.4676, 16>;
  ret->allocated_len = D.4677;
  D.4678 = ret->allocated_len;
  D.4679 = monoeg_malloc (D.4678);
  ret->str = D.4679;
  if (init != 0B) goto <D.4680>; else goto <D.4681>;
  <D.4680>:
  D.4682 = ret->str;
  D.4675 = ret->len;
  memcpy (D.4682, init, D.4675);
  <D.4681>:
  D.4682 = ret->str;
  D.4675 = ret->len;
  D.4683 = D.4682 + D.4675;
  *D.4683 = 0;
  D.4684 = ret;
  return D.4684;
}


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

  D.4687 = __builtin_object_size (__dest, 0);
  D.4686 = __builtin___memcpy_chk (__dest, __src, __len, D.4687);
  return D.4686;
}


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

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


monoeg_g_string_sized_new (gsize default_size)
{
  void * D.4691;
  char * D.4692;
  struct GString * D.4693;
  struct GString * ret;

  ret = monoeg_malloc (12);
  D.4691 = monoeg_malloc (default_size);
  ret->str = D.4691;
  D.4692 = ret->str;
  *D.4692 = 0;
  ret->len = 0;
  ret->allocated_len = default_size;
  D.4693 = ret;
  return D.4693;
}


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

  if (string == 0B) goto <D.4695>; else goto <D.4696>;
  <D.4695>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 81, "string != NULL");
  D.4697 = 0B;
  return D.4697;
  <D.4696>:
  data = string->str;
  monoeg_g_free (string);
  if (free_segment == 0) goto <D.4698>; else goto <D.4699>;
  <D.4698>:
  D.4697 = data;
  return D.4697;
  <D.4699>:
  monoeg_g_free (data);
  D.4697 = 0B;
  return D.4697;
}


monoeg_g_string_append_len (struct GString * string, const gchar * val, gssize len)
{
  struct GString * D.4703;
  unsigned int D.4708;
  unsigned int D.4709;
  unsigned int len.1;
  unsigned int D.4711;
  unsigned int D.4712;
  unsigned int D.4715;
  unsigned int D.4716;
  unsigned int D.4717;
  char * D.4718;
  void * D.4719;
  char * D.4720;
  unsigned int len.2;

  if (string == 0B) goto <D.4701>; else goto <D.4702>;
  <D.4701>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 97, "string != NULL");
  D.4703 = 0B;
  return D.4703;
  <D.4702>:
  if (val == 0B) goto <D.4704>; else goto <D.4705>;
  <D.4704>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 98, "val != NULL");
  D.4703 = string;
  return D.4703;
  <D.4705>:
  if (len < 0) goto <D.4706>; else goto <D.4707>;
  <D.4706>:
  D.4708 = strlen (val);
  len = (gssize) D.4708;
  <D.4707>:
  D.4709 = string->len;
  len.1 = (unsigned int) len;
  D.4711 = D.4709 + len.1;
  D.4712 = string->allocated_len;
  if (D.4711 >= D.4712) goto <D.4713>; else goto <D.4714>;
  <D.4713>:
  D.4712 = string->allocated_len;
  len.1 = (unsigned int) len;
  D.4715 = D.4712 + len.1;
  D.4716 = D.4715 + 16;
  D.4717 = D.4716 * 2;
  string->allocated_len = D.4717;
  D.4718 = string->str;
  D.4712 = string->allocated_len;
  D.4719 = monoeg_realloc (D.4718, D.4712);
  string->str = D.4719;
  <D.4714>:
  D.4718 = string->str;
  D.4709 = string->len;
  D.4720 = D.4718 + D.4709;
  len.2 = (unsigned int) len;
  memcpy (D.4720, val, len.2);
  D.4709 = string->len;
  len.1 = (unsigned int) len;
  D.4711 = D.4709 + len.1;
  string->len = D.4711;
  D.4718 = string->str;
  D.4709 = string->len;
  D.4720 = D.4718 + D.4709;
  *D.4720 = 0;
  D.4703 = string;
  return D.4703;
}


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

  if (string == 0B) goto <D.4723>; else goto <D.4724>;
  <D.4723>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 115, "string != NULL");
  D.4725 = 0B;
  return D.4725;
  <D.4724>:
  if (val == 0B) goto <D.4726>; else goto <D.4727>;
  <D.4726>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 116, "val != NULL");
  D.4725 = string;
  return D.4725;
  <D.4727>:
  D.4725 = monoeg_g_string_append_len (string, val, -1);
  return D.4725;
}


monoeg_g_string_append_c (struct GString * string, gchar c)
{
  struct GString * D.4731;
  unsigned int D.4732;
  unsigned int D.4733;
  unsigned int D.4734;
  unsigned int D.4737;
  unsigned int D.4738;
  char * D.4739;
  void * D.4740;
  char * D.4741;
  sizetype D.4742;
  char * D.4743;

  if (string == 0B) goto <D.4729>; else goto <D.4730>;
  <D.4729>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 124, "string != NULL");
  D.4731 = 0B;
  return D.4731;
  <D.4730>:
  D.4732 = string->len;
  D.4733 = D.4732 + 1;
  D.4734 = string->allocated_len;
  if (D.4733 >= D.4734) goto <D.4735>; else goto <D.4736>;
  <D.4735>:
  D.4734 = string->allocated_len;
  D.4737 = D.4734 + 17;
  D.4738 = D.4737 * 2;
  string->allocated_len = D.4738;
  D.4739 = string->str;
  D.4734 = string->allocated_len;
  D.4740 = monoeg_realloc (D.4739, D.4734);
  string->str = D.4740;
  <D.4736>:
  D.4739 = string->str;
  D.4732 = string->len;
  D.4741 = D.4739 + D.4732;
  *D.4741 = c;
  D.4739 = string->str;
  D.4732 = string->len;
  D.4742 = D.4732 + 1;
  D.4743 = D.4739 + D.4742;
  *D.4743 = 0;
  D.4732 = string->len;
  D.4733 = D.4732 + 1;
  string->len = D.4733;
  D.4731 = string;
  return D.4731;
}


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

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


monoeg_g_string_prepend (struct GString * string, const gchar * val)
{
  struct GString * D.4754;
  unsigned int D.4757;
  unsigned int D.4758;
  unsigned int len.3;
  unsigned int D.4760;
  unsigned int D.4761;
  unsigned int D.4764;
  unsigned int D.4765;
  unsigned int D.4766;
  char * D.4767;
  void * D.4768;
  sizetype len.4;
  void * D.4770;
  unsigned int D.4771;
  unsigned int len.5;
  gssize len;

  if (string == 0B) goto <D.4752>; else goto <D.4753>;
  <D.4752>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 154, "string != NULL");
  D.4754 = string;
  return D.4754;
  <D.4753>:
  if (val == 0B) goto <D.4755>; else goto <D.4756>;
  <D.4755>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 155, "val != NULL");
  D.4754 = string;
  return D.4754;
  <D.4756>:
  D.4757 = strlen (val);
  len = (gssize) D.4757;
  D.4758 = string->len;
  len.3 = (unsigned int) len;
  D.4760 = D.4758 + len.3;
  D.4761 = string->allocated_len;
  if (D.4760 >= D.4761) goto <D.4762>; else goto <D.4763>;
  <D.4762>:
  D.4761 = string->allocated_len;
  len.3 = (unsigned int) len;
  D.4764 = D.4761 + len.3;
  D.4765 = D.4764 + 16;
  D.4766 = D.4765 * 2;
  string->allocated_len = D.4766;
  D.4767 = string->str;
  D.4761 = string->allocated_len;
  D.4768 = monoeg_realloc (D.4767, D.4761);
  string->str = D.4768;
  <D.4763>:
  D.4767 = string->str;
  len.4 = (sizetype) len;
  D.4770 = D.4767 + len.4;
  D.4767 = string->str;
  D.4758 = string->len;
  D.4771 = D.4758 + 1;
  memmove (D.4770, D.4767, D.4771);
  D.4767 = string->str;
  len.5 = (unsigned int) len;
  memcpy (D.4767, val, len.5);
  D.4754 = string;
  return D.4754;
}


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

  D.4775 = __builtin_object_size (__dest, 0);
  D.4774 = __builtin___memmove_chk (__dest, __src, __len, D.4775);
  return D.4774;
}


monoeg_g_string_insert (struct GString * string, gssize pos, const gchar * val)
{
  struct GString * D.4779;
  unsigned int pos.6;
  unsigned int D.4783;
  unsigned int D.4786;
  unsigned int len.7;
  unsigned int D.4788;
  unsigned int D.4789;
  unsigned int D.4792;
  unsigned int D.4793;
  unsigned int D.4794;
  char * D.4795;
  void * D.4796;
  sizetype pos.8;
  sizetype len.9;
  sizetype D.4799;
  char * D.4800;
  const void * D.4801;
  unsigned int D.4802;
  unsigned int D.4803;
  unsigned int D.4804;
  char * D.4805;
  unsigned int len.10;
  gssize len;

  if (string == 0B) goto <D.4777>; else goto <D.4778>;
  <D.4777>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 171, "string != NULL");
  D.4779 = string;
  return D.4779;
  <D.4778>:
  if (val == 0B) goto <D.4780>; else goto <D.4781>;
  <D.4780>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 172, "val != NULL");
  D.4779 = string;
  return D.4779;
  <D.4781>:
  pos.6 = (unsigned int) pos;
  D.4783 = string->len;
  if (pos.6 > D.4783) goto <D.4784>; else goto <D.4785>;
  <D.4784>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 173, "pos <= string->len");
  D.4779 = string;
  return D.4779;
  <D.4785>:
  D.4786 = strlen (val);
  len = (gssize) D.4786;
  D.4783 = string->len;
  len.7 = (unsigned int) len;
  D.4788 = D.4783 + len.7;
  D.4789 = string->allocated_len;
  if (D.4788 >= D.4789) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  D.4789 = string->allocated_len;
  len.7 = (unsigned int) len;
  D.4792 = D.4789 + len.7;
  D.4793 = D.4792 + 16;
  D.4794 = D.4793 * 2;
  string->allocated_len = D.4794;
  D.4795 = string->str;
  D.4789 = string->allocated_len;
  D.4796 = monoeg_realloc (D.4795, D.4789);
  string->str = D.4796;
  <D.4791>:
  D.4795 = string->str;
  pos.8 = (sizetype) pos;
  len.9 = (sizetype) len;
  D.4799 = pos.8 + len.9;
  D.4800 = D.4795 + D.4799;
  D.4795 = string->str;
  pos.8 = (sizetype) pos;
  D.4801 = D.4795 + pos.8;
  D.4783 = string->len;
  pos.6 = (unsigned int) pos;
  D.4802 = D.4783 - pos.6;
  len.7 = (unsigned int) len;
  D.4803 = D.4802 - len.7;
  D.4804 = D.4803 + 1;
  memmove (D.4800, D.4801, D.4804);
  D.4795 = string->str;
  pos.8 = (sizetype) pos;
  D.4805 = D.4795 + pos.8;
  len.10 = (unsigned int) len;
  memcpy (D.4805, val, len.10);
  D.4779 = string;
  return D.4779;
}


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

  try
    {
      if (string == 0B) goto <D.4808>; else goto <D.4809>;
      <D.4808>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 190, "string != NULL");
      return;
      <D.4809>:
      if (format == 0B) goto <D.4810>; else goto <D.4811>;
      <D.4810>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 191, "format != NULL");
      return;
      <D.4811>:
      __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, void * args)
{
  char * ret;

  if (string == 0B) goto <D.4816>; else goto <D.4817>;
  <D.4816>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 206, "string != NULL");
  return;
  <D.4817>:
  if (format == 0B) goto <D.4818>; else goto <D.4819>;
  <D.4818>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 207, "format != NULL");
  return;
  <D.4819>:
  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.4825;
  void * args.12;
  gchar * D.4827;
  unsigned int D.4828;
  unsigned int D.4829;
  unsigned int D.4830;
  void * args;

  try
    {
      if (string == 0B) goto <D.4821>; else goto <D.4822>;
      <D.4821>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 219, "string != NULL");
      return;
      <D.4822>:
      if (format == 0B) goto <D.4823>; else goto <D.4824>;
      <D.4823>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 220, "format != NULL");
      return;
      <D.4824>:
      D.4825 = string->str;
      monoeg_g_free (D.4825);
      __builtin_va_start (&args, 0);
      args.12 = args;
      D.4827 = monoeg_g_strdup_vprintf (format, args.12);
      string->str = D.4827;
      __builtin_va_end (&args);
      D.4825 = string->str;
      D.4828 = strlen (D.4825);
      string->len = D.4828;
      D.4829 = string->len;
      D.4830 = D.4829 + 1;
      string->allocated_len = D.4830;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_string_truncate (struct GString * string, gsize len)
{
  struct GString * D.4836;
  unsigned int D.4837;
  char * D.4840;
  char * D.4841;

  if (string == 0B) goto <D.4834>; else goto <D.4835>;
  <D.4834>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 235, "string != NULL");
  D.4836 = string;
  return D.4836;
  <D.4835>:
  D.4837 = string->len;
  if (D.4837 <= len) goto <D.4838>; else goto <D.4839>;
  <D.4838>:
  D.4836 = string;
  return D.4836;
  <D.4839>:
  string->len = len;
  D.4840 = string->str;
  D.4841 = D.4840 + len;
  *D.4841 = 0;
  D.4836 = string;
  return D.4836;
}


monoeg_g_string_set_size (struct GString * string, gsize len)
{
  struct GString * D.4845;
  unsigned int D.4846;
  unsigned int D.4847;
  unsigned int D.4848;
  unsigned int D.4851;
  unsigned int D.4852;
  unsigned int D.4853;
  char * D.4854;
  void * D.4855;
  char * D.4856;

  if (string == 0B) goto <D.4843>; else goto <D.4844>;
  <D.4843>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 249, "string != NULL");
  D.4845 = string;
  return D.4845;
  <D.4844>:
  D.4846 = string->len;
  D.4847 = D.4846 + len;
  D.4848 = string->allocated_len;
  if (D.4847 >= D.4848) goto <D.4849>; else goto <D.4850>;
  <D.4849>:
  D.4848 = string->allocated_len;
  D.4851 = D.4848 + len;
  D.4852 = D.4851 + 16;
  D.4853 = D.4852 * 2;
  string->allocated_len = D.4853;
  D.4854 = string->str;
  D.4848 = string->allocated_len;
  D.4855 = monoeg_realloc (D.4854, D.4848);
  string->str = D.4855;
  <D.4850>:
  string->len = len;
  D.4854 = string->str;
  D.4856 = D.4854 + len;
  *D.4856 = 0;
  D.4845 = string;
  return D.4845;
}


monoeg_g_string_erase (struct GString * string, gssize pos, gssize len)
{
  struct GString * D.4860;
  unsigned int pos.13;
  unsigned int D.4862;
  int D.4869;
  unsigned int D.4870;
  char * D.4871;
  sizetype pos.14;
  char * D.4873;
  void * D.4874;
  sizetype len.15;
  sizetype D.4876;
  char * D.4877;
  unsigned int D.4878;
  unsigned int D.4879;
  unsigned int len.16;
  unsigned int D.4881;

  if (string == 0B) goto <D.4858>; else goto <D.4859>;
  <D.4858>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gstring.c", 261, "string != NULL");
  D.4860 = string;
  return D.4860;
  <D.4859>:
  pos.13 = (unsigned int) pos;
  D.4862 = string->len;
  if (pos.13 >= D.4862) goto <D.4863>; else goto <D.4864>;
  <D.4863>:
  D.4860 = string;
  return D.4860;
  <D.4864>:
  if (len == -1) goto <D.4865>; else goto <D.4868>;
  <D.4868>:
  D.4869 = pos + len;
  D.4870 = (unsigned int) D.4869;
  D.4862 = string->len;
  if (D.4870 >= D.4862) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  D.4871 = string->str;
  pos.14 = (sizetype) pos;
  D.4873 = D.4871 + pos.14;
  *D.4873 = 0;
  goto <D.4867>;
  <D.4866>:
  D.4871 = string->str;
  pos.14 = (sizetype) pos;
  D.4874 = D.4871 + pos.14;
  D.4871 = string->str;
  pos.14 = (sizetype) pos;
  len.15 = (sizetype) len;
  D.4876 = pos.14 + len.15;
  D.4877 = D.4871 + D.4876;
  D.4862 = string->len;
  D.4869 = pos + len;
  D.4870 = (unsigned int) D.4869;
  D.4878 = D.4862 - D.4870;
  D.4879 = D.4878 + 1;
  memmove (D.4874, D.4877, D.4879);
  D.4862 = string->len;
  len.16 = (unsigned int) len;
  D.4881 = D.4862 - len.16;
  string->len = D.4881;
  <D.4867>:
  D.4860 = string;
  return D.4860;
}