test_append_speed ()
{
  char * D.5070;
  long unsigned int D.5071;
  gchar * D.5074;
  long unsigned int D.5075;
  struct GString * s;
  gint i;

  s = monoeg_g_string_new ("");
  i = 0;
  goto <D.4951>;
  <D.4950>:
  monoeg_g_string_append (s, "x");
  i = i + 1;
  <D.4951>:
  if (i <= 1023) goto <D.4950>; else goto <D.4952>;
  <D.4952>:
  D.5070 = s->str;
  D.5071 = strlen (D.5070);
  if (D.5071 != 1024) goto <D.5072>; else goto <D.5073>;
  <D.5072>:
  D.5070 = s->str;
  D.5075 = strlen (D.5070);
  D.5070 = s->str;
  D.5074 = FAILED ("Incorrect string size, got: %s %d", D.5070, D.5075);
  return D.5074;
  <D.5073>:
  monoeg_g_string_free (s, 1);
  D.5074 = 0B;
  return D.5074;
}


test_append_c_speed ()
{
  char * D.5077;
  long unsigned int D.5078;
  gchar * D.5081;
  long unsigned int D.5082;
  struct GString * s;
  gint i;

  s = monoeg_g_string_new ("");
  i = 0;
  goto <D.4958>;
  <D.4957>:
  monoeg_g_string_append_c (s, 120);
  i = i + 1;
  <D.4958>:
  if (i <= 1023) goto <D.4957>; else goto <D.4959>;
  <D.4959>:
  D.5077 = s->str;
  D.5078 = strlen (D.5077);
  if (D.5078 != 1024) goto <D.5079>; else goto <D.5080>;
  <D.5079>:
  D.5077 = s->str;
  D.5082 = strlen (D.5077);
  D.5077 = s->str;
  D.5081 = FAILED ("Incorrect string size, got: %s %d", D.5077, D.5082);
  return D.5081;
  <D.5080>:
  monoeg_g_string_free (s, 1);
  D.5081 = 0B;
  return D.5081;
}


test_gstring ()
{
  int D.4973;
  int iftmp.0;
  int D.4972;
  char[3] * D.5087;
  unsigned char D.5088;
  int D.5089;
  unsigned char D.5090;
  int D.5091;
  _Bool D.5092;
  _Bool D.5093;
  _Bool D.5094;
  const unsigned char * D.5097;
  unsigned char D.5098;
  int D.5099;
  const unsigned char * D.5100;
  unsigned char D.5101;
  int D.5102;
  _Bool D.5103;
  _Bool D.5104;
  const unsigned char * D.5107;
  unsigned char D.5108;
  int D.5109;
  const unsigned char * D.5110;
  unsigned char D.5111;
  int D.5112;
  _Bool D.5113;
  _Bool D.5114;
  const unsigned char * D.5117;
  unsigned char D.5118;
  int D.5119;
  const unsigned char * D.5120;
  unsigned char D.5121;
  int D.5122;
  char * D.5124;
  gchar * D.5127;
  char * D.5128;
  char D.5129;
  int D.4982;
  int iftmp.1;
  int D.4981;
  char[3] * D.5135;
  unsigned char D.5136;
  int D.5137;
  unsigned char D.5138;
  int D.5139;
  _Bool D.5140;
  _Bool D.5141;
  _Bool D.5142;
  const unsigned char * D.5145;
  unsigned char D.5146;
  int D.5147;
  const unsigned char * D.5148;
  unsigned char D.5149;
  int D.5150;
  _Bool D.5151;
  _Bool D.5152;
  const unsigned char * D.5155;
  unsigned char D.5156;
  int D.5157;
  const unsigned char * D.5158;
  unsigned char D.5159;
  int D.5160;
  _Bool D.5161;
  _Bool D.5162;
  const unsigned char * D.5165;
  unsigned char D.5166;
  int D.5167;
  const unsigned char * D.5168;
  unsigned char D.5169;
  int D.5170;
  const char * D.5172;
  int D.5177;
  char * D.5180;
  long unsigned int D.5181;
  long unsigned int D.5184;
  int D.5003;
  int iftmp.2;
  int D.5002;
  char[12] * D.5188;
  unsigned char D.5189;
  int D.5190;
  unsigned char D.5191;
  int D.5192;
  _Bool D.5193;
  _Bool D.5194;
  _Bool D.5195;
  const unsigned char * D.5198;
  unsigned char D.5199;
  int D.5200;
  const unsigned char * D.5201;
  unsigned char D.5202;
  int D.5203;
  _Bool D.5204;
  _Bool D.5205;
  const unsigned char * D.5208;
  unsigned char D.5209;
  int D.5210;
  const unsigned char * D.5211;
  unsigned char D.5212;
  int D.5213;
  _Bool D.5214;
  _Bool D.5215;
  const unsigned char * D.5218;
  unsigned char D.5219;
  int D.5220;
  const unsigned char * D.5221;
  unsigned char D.5222;
  int D.5223;
  char D.5227;
  char * D.5230;
  char D.5231;
  char * D.5236;
  char D.5237;
  char D.5240;
  char * D.5243;
  char D.5244;
  struct GString * s;
  char * ret;
  int i;

  s = monoeg_g_string_new_len ("My stuff", 2);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.5085>; else goto <D.5086>;
    <D.5085>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5087 = "My";
      D.5088 = MEM[(const unsigned char *)D.5087];
      D.5089 = (int) D.5088;
      D.5090 = *__s2;
      D.5091 = (int) D.5090;
      __result = D.5089 - D.5091;
      {
        D.5092 = __s2_len != 0;
        D.5093 = __result == 0;
        D.5094 = D.5092 & D.5093;
        if (D.5094 != 0) goto <D.5095>; else goto <D.5096>;
        <D.5095>:
        D.5097 = &MEM[(void *)"My" + 1B];
        D.5098 = *D.5097;
        D.5099 = (int) D.5098;
        D.5100 = __s2 + 1;
        D.5101 = *D.5100;
        D.5102 = (int) D.5101;
        __result = D.5099 - D.5102;
        D.5103 = __s2_len > 1;
        D.5093 = __result == 0;
        D.5104 = D.5103 & D.5093;
        if (D.5104 != 0) goto <D.5105>; else goto <D.5106>;
        <D.5105>:
        D.5107 = &MEM[(void *)"My" + 2B];
        D.5108 = *D.5107;
        D.5109 = (int) D.5108;
        D.5110 = __s2 + 2;
        D.5111 = *D.5110;
        D.5112 = (int) D.5111;
        __result = D.5109 - D.5112;
        D.5113 = __s2_len > 2;
        D.5093 = __result == 0;
        D.5114 = D.5113 & D.5093;
        if (D.5114 != 0) goto <D.5115>; else goto <D.5116>;
        <D.5115>:
        D.5117 = &MEM[(void *)"My" + 3B];
        D.5118 = *D.5117;
        D.5119 = (int) D.5118;
        D.5120 = __s2 + 3;
        D.5121 = *D.5120;
        D.5122 = (int) D.5121;
        __result = D.5119 - D.5122;
        <D.5116>:
        <D.5106>:
        <D.5096>:
      }
      D.4972 = __result;
    }
    iftmp.0 = -D.4972;
    goto <D.5123>;
    <D.5086>:
    D.5124 = s->str;
    iftmp.0 = __builtin_strcmp (D.5124, "My");
    <D.5123>:
    D.4973 = iftmp.0;
  }
  if (D.4973 != 0) goto <D.5125>; else goto <D.5126>;
  <D.5125>:
  D.5127 = "Expected only \'My\' on the string";
  return D.5127;
  <D.5126>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new_len ("My", 6);
  D.5124 = s->str;
  D.5128 = D.5124 + 2;
  D.5129 = *D.5128;
  if (D.5129 != 0) goto <D.5130>; else goto <D.5131>;
  <D.5130>:
  D.5127 = "Null was not copied";
  return D.5127;
  <D.5131>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.5133>; else goto <D.5134>;
    <D.5133>:
    {
      const unsigned char * __s2;
      int __result;

      D.5124 = s->str;
      __s2 = D.5124 + 4;
      D.5135 = "Re";
      D.5136 = MEM[(const unsigned char *)D.5135];
      D.5137 = (int) D.5136;
      D.5138 = *__s2;
      D.5139 = (int) D.5138;
      __result = D.5137 - D.5139;
      {
        D.5140 = __s2_len != 0;
        D.5141 = __result == 0;
        D.5142 = D.5140 & D.5141;
        if (D.5142 != 0) goto <D.5143>; else goto <D.5144>;
        <D.5143>:
        D.5145 = &MEM[(void *)"Re" + 1B];
        D.5146 = *D.5145;
        D.5147 = (int) D.5146;
        D.5148 = __s2 + 1;
        D.5149 = *D.5148;
        D.5150 = (int) D.5149;
        __result = D.5147 - D.5150;
        D.5151 = __s2_len > 1;
        D.5141 = __result == 0;
        D.5152 = D.5151 & D.5141;
        if (D.5152 != 0) goto <D.5153>; else goto <D.5154>;
        <D.5153>:
        D.5155 = &MEM[(void *)"Re" + 2B];
        D.5156 = *D.5155;
        D.5157 = (int) D.5156;
        D.5158 = __s2 + 2;
        D.5159 = *D.5158;
        D.5160 = (int) D.5159;
        __result = D.5157 - D.5160;
        D.5161 = __s2_len > 2;
        D.5141 = __result == 0;
        D.5162 = D.5161 & D.5141;
        if (D.5162 != 0) goto <D.5163>; else goto <D.5164>;
        <D.5163>:
        D.5165 = &MEM[(void *)"Re" + 3B];
        D.5166 = *D.5165;
        D.5167 = (int) D.5166;
        D.5168 = __s2 + 3;
        D.5169 = *D.5168;
        D.5170 = (int) D.5169;
        __result = D.5167 - D.5170;
        <D.5164>:
        <D.5154>:
        <D.5144>:
      }
      D.4981 = __result;
    }
    iftmp.1 = -D.4981;
    goto <D.5171>;
    <D.5134>:
    D.5124 = s->str;
    D.5172 = D.5124 + 4;
    iftmp.1 = __builtin_strcmp (D.5172, "Re");
    <D.5171>:
    D.4982 = iftmp.1;
  }
  if (D.4982 != 0) goto <D.5173>; else goto <D.5174>;
  <D.5173>:
  D.5127 = "Did not find the \'Re\' part";
  return D.5127;
  <D.5174>:
  monoeg_g_string_append (s, "lalalalalalalalalalalalalalalalalalalalalalal");
  D.5124 = s->str;
  D.5128 = D.5124 + 2;
  D.5129 = *D.5128;
  if (D.5129 != 0) goto <D.5175>; else goto <D.5176>;
  <D.5175>:
  D.5127 = "Null as not copied";
  return D.5127;
  <D.5176>:
  D.5124 = s->str;
  D.5172 = D.5124 + 4;
  D.5177 = strncmp (D.5172, "Relala", 6);
  if (D.5177 != 0) goto <D.5178>; else goto <D.5179>;
  <D.5178>:
  D.5124 = s->str;
  D.5180 = D.5124 + 4;
  D.5127 = FAILED ("Did not copy correctly, got: %s", D.5180);
  return D.5127;
  <D.5179>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new ("");
  i = 0;
  goto <D.4993>;
  <D.4992>:
  monoeg_g_string_append_c (s, 120);
  i = i + 1;
  <D.4993>:
  if (i <= 1023) goto <D.4992>; else goto <D.4994>;
  <D.4994>:
  D.5124 = s->str;
  D.5181 = strlen (D.5124);
  if (D.5181 != 1024) goto <D.5182>; else goto <D.5183>;
  <D.5182>:
  D.5124 = s->str;
  D.5184 = strlen (D.5124);
  D.5124 = s->str;
  D.5127 = FAILED ("Incorrect string size, got: %s %d\n", D.5124, D.5184);
  return D.5127;
  <D.5183>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new ("hola");
  monoeg_g_string_append_printf (s, "%s%d", ", bola", 5);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.5186>; else goto <D.5187>;
    <D.5186>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5188 = "hola, bola5";
      D.5189 = MEM[(const unsigned char *)D.5188];
      D.5190 = (int) D.5189;
      D.5191 = *__s2;
      D.5192 = (int) D.5191;
      __result = D.5190 - D.5192;
      {
        D.5193 = __s2_len != 0;
        D.5194 = __result == 0;
        D.5195 = D.5193 & D.5194;
        if (D.5195 != 0) goto <D.5196>; else goto <D.5197>;
        <D.5196>:
        D.5198 = &MEM[(void *)"hola, bola5" + 1B];
        D.5199 = *D.5198;
        D.5200 = (int) D.5199;
        D.5201 = __s2 + 1;
        D.5202 = *D.5201;
        D.5203 = (int) D.5202;
        __result = D.5200 - D.5203;
        D.5204 = __s2_len > 1;
        D.5194 = __result == 0;
        D.5205 = D.5204 & D.5194;
        if (D.5205 != 0) goto <D.5206>; else goto <D.5207>;
        <D.5206>:
        D.5208 = &MEM[(void *)"hola, bola5" + 2B];
        D.5209 = *D.5208;
        D.5210 = (int) D.5209;
        D.5211 = __s2 + 2;
        D.5212 = *D.5211;
        D.5213 = (int) D.5212;
        __result = D.5210 - D.5213;
        D.5214 = __s2_len > 2;
        D.5194 = __result == 0;
        D.5215 = D.5214 & D.5194;
        if (D.5215 != 0) goto <D.5216>; else goto <D.5217>;
        <D.5216>:
        D.5218 = &MEM[(void *)"hola, bola5" + 3B];
        D.5219 = *D.5218;
        D.5220 = (int) D.5219;
        D.5221 = __s2 + 3;
        D.5222 = *D.5221;
        D.5223 = (int) D.5222;
        __result = D.5220 - D.5223;
        <D.5217>:
        <D.5207>:
        <D.5197>:
      }
      D.5002 = __result;
    }
    iftmp.2 = -D.5002;
    goto <D.5224>;
    <D.5187>:
    D.5124 = s->str;
    iftmp.2 = __builtin_strcmp (D.5124, "hola, bola5");
    <D.5224>:
    D.5003 = iftmp.2;
  }
  if (D.5003 != 0) goto <D.5225>; else goto <D.5226>;
  <D.5225>:
  D.5124 = s->str;
  D.5127 = FAILED ("Incorrect data, got: %s\n", D.5124);
  return D.5127;
  <D.5226>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new ("Hola");
  monoeg_g_string_printf (s, "Dingus");
  ret = monoeg_g_string_free (s, 0);
  monoeg_g_free (ret);
  s = monoeg_g_string_new_len ("H", 3);
  monoeg_g_string_append_len (s, "1", 3);
  D.5124 = s->str;
  D.5227 = *D.5124;
  if (D.5227 != 72) goto <D.5228>; else goto <D.5229>;
  <D.5228>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 0, 72);
  return D.5127;
  <D.5229>:
  D.5124 = s->str;
  D.5230 = D.5124 + 1;
  D.5231 = *D.5230;
  if (D.5231 != 0) goto <D.5232>; else goto <D.5233>;
  <D.5232>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 1, 0);
  return D.5127;
  <D.5233>:
  D.5124 = s->str;
  D.5128 = D.5124 + 2;
  D.5129 = *D.5128;
  if (D.5129 != 72) goto <D.5234>; else goto <D.5235>;
  <D.5234>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 2, 72);
  return D.5127;
  <D.5235>:
  D.5124 = s->str;
  D.5236 = D.5124 + 3;
  D.5237 = *D.5236;
  if (D.5237 != 49) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 3, 49);
  return D.5127;
  <D.5239>:
  D.5124 = s->str;
  D.5180 = D.5124 + 4;
  D.5240 = *D.5180;
  if (D.5240 != 0) goto <D.5241>; else goto <D.5242>;
  <D.5241>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 4, 0);
  return D.5127;
  <D.5242>:
  D.5124 = s->str;
  D.5243 = D.5124 + 5;
  D.5244 = *D.5243;
  if (D.5244 != 50) goto <D.5245>; else goto <D.5246>;
  <D.5245>:
  monoeg_g_string_free (s, 1);
  D.5124 = s->str;
  D.5127 = FAILED ("Got %s, Failed at %d, expected \'%c\'", D.5124, 5, 50);
  return D.5127;
  <D.5246>:
  monoeg_g_string_free (s, 1);
  D.5127 = 0B;
  return D.5127;
}


test_sized ()
{
  char * D.5248;
  char D.5249;
  gchar * D.5252;
  long unsigned int D.5253;
  struct GString * s;

  s = monoeg_g_string_sized_new (20);
  D.5248 = s->str;
  D.5249 = *D.5248;
  if (D.5249 != 0) goto <D.5250>; else goto <D.5251>;
  <D.5250>:
  D.5252 = FAILED ("Expected an empty string");
  return D.5252;
  <D.5251>:
  D.5253 = s->len;
  if (D.5253 != 0) goto <D.5254>; else goto <D.5255>;
  <D.5254>:
  D.5252 = FAILED ("Expected an empty len");
  return D.5252;
  <D.5255>:
  monoeg_g_string_free (s, 1);
  D.5252 = 0B;
  return D.5252;
}


test_truncate ()
{
  char * D.5257;
  long unsigned int D.5258;
  gchar * D.5261;
  long unsigned int D.5262;
  long unsigned int D.5265;
  char D.5268;
  struct GString * s;

  s = monoeg_g_string_new ("0123456789");
  monoeg_g_string_truncate (s, 3);
  D.5257 = s->str;
  D.5258 = strlen (D.5257);
  if (D.5258 != 3) goto <D.5259>; else goto <D.5260>;
  <D.5259>:
  D.5257 = s->str;
  D.5261 = FAILED ("size of string should have been 3, instead it is [%s]\n", D.5257);
  return D.5261;
  <D.5260>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new ("a");
  s = monoeg_g_string_truncate (s, 10);
  D.5257 = s->str;
  D.5262 = strlen (D.5257);
  if (D.5262 != 1) goto <D.5263>; else goto <D.5264>;
  <D.5263>:
  D.5261 = FAILED ("The size is not 1");
  return D.5261;
  <D.5264>:
  monoeg_g_string_truncate (s, 18446744073709551615);
  D.5257 = s->str;
  D.5265 = strlen (D.5257);
  if (D.5265 != 1) goto <D.5266>; else goto <D.5267>;
  <D.5266>:
  D.5261 = FAILED ("The size is not 1");
  return D.5261;
  <D.5267>:
  monoeg_g_string_truncate (s, 0);
  D.5257 = s->str;
  D.5268 = MEM[(const char *)D.5257];
  if (D.5268 != 0) goto <D.5269>; else goto <D.5270>;
  <D.5269>:
  D.5261 = FAILED ("The size is not 0");
  return D.5261;
  <D.5270>:
  monoeg_g_string_free (s, 1);
  D.5261 = 0B;
  return D.5261;
}


test_prepend ()
{
  int D.5021;
  int iftmp.3;
  int D.5020;
  char[10] * D.5275;
  unsigned char D.5276;
  int D.5277;
  unsigned char D.5278;
  int D.5279;
  _Bool D.5280;
  _Bool D.5281;
  _Bool D.5282;
  const unsigned char * D.5285;
  unsigned char D.5286;
  int D.5287;
  const unsigned char * D.5288;
  unsigned char D.5289;
  int D.5290;
  _Bool D.5291;
  _Bool D.5292;
  const unsigned char * D.5295;
  unsigned char D.5296;
  int D.5297;
  const unsigned char * D.5298;
  unsigned char D.5299;
  int D.5300;
  _Bool D.5301;
  _Bool D.5302;
  const unsigned char * D.5305;
  unsigned char D.5306;
  int D.5307;
  const unsigned char * D.5308;
  unsigned char D.5309;
  int D.5310;
  char * D.5312;
  gchar * D.5315;
  int D.5030;
  int iftmp.4;
  int D.5029;
  char[4] * D.5319;
  unsigned char D.5320;
  int D.5321;
  unsigned char D.5322;
  int D.5323;
  _Bool D.5324;
  _Bool D.5325;
  _Bool D.5326;
  const unsigned char * D.5329;
  unsigned char D.5330;
  int D.5331;
  const unsigned char * D.5332;
  unsigned char D.5333;
  int D.5334;
  _Bool D.5335;
  _Bool D.5336;
  const unsigned char * D.5339;
  unsigned char D.5340;
  int D.5341;
  const unsigned char * D.5342;
  unsigned char D.5343;
  int D.5344;
  _Bool D.5345;
  _Bool D.5346;
  const unsigned char * D.5349;
  unsigned char D.5350;
  int D.5351;
  const unsigned char * D.5352;
  unsigned char D.5353;
  int D.5354;
  int D.5039;
  int iftmp.5;
  int D.5038;
  char[2] * D.5361;
  unsigned char D.5362;
  int D.5363;
  unsigned char D.5364;
  int D.5365;
  _Bool D.5366;
  _Bool D.5367;
  _Bool D.5368;
  const unsigned char * D.5371;
  unsigned char D.5372;
  int D.5373;
  const unsigned char * D.5374;
  unsigned char D.5375;
  int D.5376;
  _Bool D.5377;
  _Bool D.5378;
  const unsigned char * D.5381;
  unsigned char D.5382;
  int D.5383;
  const unsigned char * D.5384;
  unsigned char D.5385;
  int D.5386;
  _Bool D.5387;
  _Bool D.5388;
  const unsigned char * D.5391;
  unsigned char D.5392;
  int D.5393;
  const unsigned char * D.5394;
  unsigned char D.5395;
  int D.5396;
  int D.5048;
  int iftmp.6;
  int D.5047;
  char[5] * D.5403;
  unsigned char D.5404;
  int D.5405;
  unsigned char D.5406;
  int D.5407;
  _Bool D.5408;
  _Bool D.5409;
  _Bool D.5410;
  const unsigned char * D.5413;
  unsigned char D.5414;
  int D.5415;
  const unsigned char * D.5416;
  unsigned char D.5417;
  int D.5418;
  _Bool D.5419;
  _Bool D.5420;
  const unsigned char * D.5423;
  unsigned char D.5424;
  int D.5425;
  const unsigned char * D.5426;
  unsigned char D.5427;
  int D.5428;
  _Bool D.5429;
  _Bool D.5430;
  const unsigned char * D.5433;
  unsigned char D.5434;
  int D.5435;
  const unsigned char * D.5436;
  unsigned char D.5437;
  int D.5438;
  struct GString * s;

  s = monoeg_g_string_new ("dingus");
  monoeg_g_string_prepend (s, "one");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.5273>; else goto <D.5274>;
    <D.5273>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5275 = "onedingus";
      D.5276 = MEM[(const unsigned char *)D.5275];
      D.5277 = (int) D.5276;
      D.5278 = *__s2;
      D.5279 = (int) D.5278;
      __result = D.5277 - D.5279;
      {
        D.5280 = __s2_len != 0;
        D.5281 = __result == 0;
        D.5282 = D.5280 & D.5281;
        if (D.5282 != 0) goto <D.5283>; else goto <D.5284>;
        <D.5283>:
        D.5285 = &MEM[(void *)"onedingus" + 1B];
        D.5286 = *D.5285;
        D.5287 = (int) D.5286;
        D.5288 = __s2 + 1;
        D.5289 = *D.5288;
        D.5290 = (int) D.5289;
        __result = D.5287 - D.5290;
        D.5291 = __s2_len > 1;
        D.5281 = __result == 0;
        D.5292 = D.5291 & D.5281;
        if (D.5292 != 0) goto <D.5293>; else goto <D.5294>;
        <D.5293>:
        D.5295 = &MEM[(void *)"onedingus" + 2B];
        D.5296 = *D.5295;
        D.5297 = (int) D.5296;
        D.5298 = __s2 + 2;
        D.5299 = *D.5298;
        D.5300 = (int) D.5299;
        __result = D.5297 - D.5300;
        D.5301 = __s2_len > 2;
        D.5281 = __result == 0;
        D.5302 = D.5301 & D.5281;
        if (D.5302 != 0) goto <D.5303>; else goto <D.5304>;
        <D.5303>:
        D.5305 = &MEM[(void *)"onedingus" + 3B];
        D.5306 = *D.5305;
        D.5307 = (int) D.5306;
        D.5308 = __s2 + 3;
        D.5309 = *D.5308;
        D.5310 = (int) D.5309;
        __result = D.5307 - D.5310;
        <D.5304>:
        <D.5294>:
        <D.5284>:
      }
      D.5020 = __result;
    }
    iftmp.3 = -D.5020;
    goto <D.5311>;
    <D.5274>:
    D.5312 = s->str;
    iftmp.3 = __builtin_strcmp (D.5312, "onedingus");
    <D.5311>:
    D.5021 = iftmp.3;
  }
  if (D.5021 != 0) goto <D.5313>; else goto <D.5314>;
  <D.5313>:
  D.5312 = s->str;
  D.5315 = FAILED ("Failed, expected onedingus, got [%s]", D.5312);
  return D.5315;
  <D.5314>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_sized_new (1);
  monoeg_g_string_prepend (s, "one");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.5317>; else goto <D.5318>;
    <D.5317>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5319 = "one";
      D.5320 = MEM[(const unsigned char *)D.5319];
      D.5321 = (int) D.5320;
      D.5322 = *__s2;
      D.5323 = (int) D.5322;
      __result = D.5321 - D.5323;
      {
        D.5324 = __s2_len != 0;
        D.5325 = __result == 0;
        D.5326 = D.5324 & D.5325;
        if (D.5326 != 0) goto <D.5327>; else goto <D.5328>;
        <D.5327>:
        D.5329 = &MEM[(void *)"one" + 1B];
        D.5330 = *D.5329;
        D.5331 = (int) D.5330;
        D.5332 = __s2 + 1;
        D.5333 = *D.5332;
        D.5334 = (int) D.5333;
        __result = D.5331 - D.5334;
        D.5335 = __s2_len > 1;
        D.5325 = __result == 0;
        D.5336 = D.5335 & D.5325;
        if (D.5336 != 0) goto <D.5337>; else goto <D.5338>;
        <D.5337>:
        D.5339 = &MEM[(void *)"one" + 2B];
        D.5340 = *D.5339;
        D.5341 = (int) D.5340;
        D.5342 = __s2 + 2;
        D.5343 = *D.5342;
        D.5344 = (int) D.5343;
        __result = D.5341 - D.5344;
        D.5345 = __s2_len > 2;
        D.5325 = __result == 0;
        D.5346 = D.5345 & D.5325;
        if (D.5346 != 0) goto <D.5347>; else goto <D.5348>;
        <D.5347>:
        D.5349 = &MEM[(void *)"one" + 3B];
        D.5350 = *D.5349;
        D.5351 = (int) D.5350;
        D.5352 = __s2 + 3;
        D.5353 = *D.5352;
        D.5354 = (int) D.5353;
        __result = D.5351 - D.5354;
        <D.5348>:
        <D.5338>:
        <D.5328>:
      }
      D.5029 = __result;
    }
    iftmp.4 = -D.5029;
    goto <D.5355>;
    <D.5318>:
    D.5312 = s->str;
    iftmp.4 = __builtin_strcmp (D.5312, "one");
    <D.5355>:
    D.5030 = iftmp.4;
  }
  if (D.5030 != 0) goto <D.5356>; else goto <D.5357>;
  <D.5356>:
  D.5312 = s->str;
  D.5315 = FAILED ("Got erroneous result, expected [one] got [%s]", D.5312);
  return D.5315;
  <D.5357>:
  monoeg_g_string_free (s, 1);
  s = monoeg_g_string_new ("123123123123123123123123");
  monoeg_g_string_truncate (s, 1);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.5359>; else goto <D.5360>;
    <D.5359>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5361 = "1";
      D.5362 = MEM[(const unsigned char *)D.5361];
      D.5363 = (int) D.5362;
      D.5364 = *__s2;
      D.5365 = (int) D.5364;
      __result = D.5363 - D.5365;
      {
        D.5366 = __s2_len != 0;
        D.5367 = __result == 0;
        D.5368 = D.5366 & D.5367;
        if (D.5368 != 0) goto <D.5369>; else goto <D.5370>;
        <D.5369>:
        D.5371 = &MEM[(void *)"1" + 1B];
        D.5372 = *D.5371;
        D.5373 = (int) D.5372;
        D.5374 = __s2 + 1;
        D.5375 = *D.5374;
        D.5376 = (int) D.5375;
        __result = D.5373 - D.5376;
        D.5377 = __s2_len > 1;
        D.5367 = __result == 0;
        D.5378 = D.5377 & D.5367;
        if (D.5378 != 0) goto <D.5379>; else goto <D.5380>;
        <D.5379>:
        D.5381 = &MEM[(void *)"1" + 2B];
        D.5382 = *D.5381;
        D.5383 = (int) D.5382;
        D.5384 = __s2 + 2;
        D.5385 = *D.5384;
        D.5386 = (int) D.5385;
        __result = D.5383 - D.5386;
        D.5387 = __s2_len > 2;
        D.5367 = __result == 0;
        D.5388 = D.5387 & D.5367;
        if (D.5388 != 0) goto <D.5389>; else goto <D.5390>;
        <D.5389>:
        D.5391 = &MEM[(void *)"1" + 3B];
        D.5392 = *D.5391;
        D.5393 = (int) D.5392;
        D.5394 = __s2 + 3;
        D.5395 = *D.5394;
        D.5396 = (int) D.5395;
        __result = D.5393 - D.5396;
        <D.5390>:
        <D.5380>:
        <D.5370>:
      }
      D.5038 = __result;
    }
    iftmp.5 = -D.5038;
    goto <D.5397>;
    <D.5360>:
    D.5312 = s->str;
    iftmp.5 = __builtin_strcmp (D.5312, "1");
    <D.5397>:
    D.5039 = iftmp.5;
  }
  if (D.5039 != 0) goto <D.5398>; else goto <D.5399>;
  <D.5398>:
  D.5312 = s->str;
  D.5315 = FAILED ("Expected [1] string, got [%s]", D.5312);
  return D.5315;
  <D.5399>:
  monoeg_g_string_prepend (s, "pre");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.5401>; else goto <D.5402>;
    <D.5401>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s->str;
      D.5403 = "pre1";
      D.5404 = MEM[(const unsigned char *)D.5403];
      D.5405 = (int) D.5404;
      D.5406 = *__s2;
      D.5407 = (int) D.5406;
      __result = D.5405 - D.5407;
      {
        D.5408 = __s2_len != 0;
        D.5409 = __result == 0;
        D.5410 = D.5408 & D.5409;
        if (D.5410 != 0) goto <D.5411>; else goto <D.5412>;
        <D.5411>:
        D.5413 = &MEM[(void *)"pre1" + 1B];
        D.5414 = *D.5413;
        D.5415 = (int) D.5414;
        D.5416 = __s2 + 1;
        D.5417 = *D.5416;
        D.5418 = (int) D.5417;
        __result = D.5415 - D.5418;
        D.5419 = __s2_len > 1;
        D.5409 = __result == 0;
        D.5420 = D.5419 & D.5409;
        if (D.5420 != 0) goto <D.5421>; else goto <D.5422>;
        <D.5421>:
        D.5423 = &MEM[(void *)"pre1" + 2B];
        D.5424 = *D.5423;
        D.5425 = (int) D.5424;
        D.5426 = __s2 + 2;
        D.5427 = *D.5426;
        D.5428 = (int) D.5427;
        __result = D.5425 - D.5428;
        D.5429 = __s2_len > 2;
        D.5409 = __result == 0;
        D.5430 = D.5429 & D.5409;
        if (D.5430 != 0) goto <D.5431>; else goto <D.5432>;
        <D.5431>:
        D.5433 = &MEM[(void *)"pre1" + 3B];
        D.5434 = *D.5433;
        D.5435 = (int) D.5434;
        D.5436 = __s2 + 3;
        D.5437 = *D.5436;
        D.5438 = (int) D.5437;
        __result = D.5435 - D.5438;
        <D.5432>:
        <D.5422>:
        <D.5412>:
      }
      D.5047 = __result;
    }
    iftmp.6 = -D.5047;
    goto <D.5439>;
    <D.5402>:
    D.5312 = s->str;
    iftmp.6 = __builtin_strcmp (D.5312, "pre1");
    <D.5439>:
    D.5048 = iftmp.6;
  }
  if (D.5048 != 0) goto <D.5440>; else goto <D.5441>;
  <D.5440>:
  D.5312 = s->str;
  D.5315 = FAILED ("Expected [pre1], got [%s]", D.5312);
  return D.5315;
  <D.5441>:
  monoeg_g_string_free (s, 1);
  D.5315 = 0B;
  return D.5315;
}


test_appendlen ()
{
  long unsigned int D.5443;
  gchar * D.5446;
  struct GString * s;

  s = monoeg_g_string_new ("");
  monoeg_g_string_append_len (s, "boo", 0);
  D.5443 = s->len;
  if (D.5443 != 0) goto <D.5444>; else goto <D.5445>;
  <D.5444>:
  D.5443 = s->len;
  D.5446 = FAILED ("The length is not zero %d", D.5443);
  return D.5446;
  <D.5445>:
  monoeg_g_string_append_len (s, "boo", 5);
  D.5443 = s->len;
  if (D.5443 != 5) goto <D.5447>; else goto <D.5448>;
  <D.5447>:
  D.5443 = s->len;
  D.5446 = FAILED ("The length is not five %d", D.5443);
  return D.5446;
  <D.5448>:
  monoeg_g_string_append_len (s, "ha", -1);
  D.5443 = s->len;
  if (D.5443 != 7) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  D.5443 = s->len;
  D.5446 = FAILED ("The length is not seven %d", D.5443);
  return D.5446;
  <D.5450>:
  monoeg_g_string_free (s, 1);
  D.5446 = 0B;
  return D.5446;
}


test_macros ()
{
  const char * D.5452;
  gchar * D.5455;
  const char * D.5456;
  int D.5065;
  int iftmp.7;
  int D.5064;
  long unsigned int D.5462;
  sizetype D.5463;
  char[9] * D.5464;
  unsigned char D.5465;
  int D.5466;
  unsigned char D.5467;
  int D.5468;
  _Bool D.5469;
  _Bool D.5470;
  _Bool D.5471;
  const unsigned char * D.5474;
  unsigned char D.5475;
  int D.5476;
  const unsigned char * D.5477;
  unsigned char D.5478;
  int D.5479;
  _Bool D.5480;
  _Bool D.5481;
  const unsigned char * D.5484;
  unsigned char D.5485;
  int D.5486;
  const unsigned char * D.5487;
  unsigned char D.5488;
  int D.5489;
  _Bool D.5490;
  _Bool D.5491;
  const unsigned char * D.5494;
  unsigned char D.5495;
  int D.5496;
  const unsigned char * D.5497;
  unsigned char D.5498;
  int D.5499;
  long unsigned int D.5501;
  sizetype D.5502;
  char * D.5503;
  char * s;
  char * p;
  int n;

  s = monoeg_strdup ("string.c:207:");
  D.5452 = s + 2;
  p = __builtin_strchr (D.5452, 58);
  if (p == 0B) goto <D.5453>; else goto <D.5454>;
  <D.5453>:
  D.5455 = FAILED ("Did not find a separator");
  return D.5455;
  <D.5454>:
  D.5456 = p + 1;
  n = atoi (D.5456);
  if (n <= 0) goto <D.5457>; else goto <D.5458>;
  <D.5457>:
  D.5455 = FAILED ("did not find a valid line number");
  return D.5455;
  <D.5458>:
  *p = 0;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.5460>; else goto <D.5461>;
    <D.5460>:
    {
      const unsigned char * __s2;
      int __result;

      D.5462 = strlen (s);
      D.5463 = D.5462 + 18446744073709551608;
      __s2 = s + D.5463;
      D.5464 = "string.c";
      D.5465 = MEM[(const unsigned char *)D.5464];
      D.5466 = (int) D.5465;
      D.5467 = *__s2;
      D.5468 = (int) D.5467;
      __result = D.5466 - D.5468;
      {
        D.5469 = __s2_len != 0;
        D.5470 = __result == 0;
        D.5471 = D.5469 & D.5470;
        if (D.5471 != 0) goto <D.5472>; else goto <D.5473>;
        <D.5472>:
        D.5474 = &MEM[(void *)"string.c" + 1B];
        D.5475 = *D.5474;
        D.5476 = (int) D.5475;
        D.5477 = __s2 + 1;
        D.5478 = *D.5477;
        D.5479 = (int) D.5478;
        __result = D.5476 - D.5479;
        D.5480 = __s2_len > 1;
        D.5470 = __result == 0;
        D.5481 = D.5480 & D.5470;
        if (D.5481 != 0) goto <D.5482>; else goto <D.5483>;
        <D.5482>:
        D.5484 = &MEM[(void *)"string.c" + 2B];
        D.5485 = *D.5484;
        D.5486 = (int) D.5485;
        D.5487 = __s2 + 2;
        D.5488 = *D.5487;
        D.5489 = (int) D.5488;
        __result = D.5486 - D.5489;
        D.5490 = __s2_len > 2;
        D.5470 = __result == 0;
        D.5491 = D.5490 & D.5470;
        if (D.5491 != 0) goto <D.5492>; else goto <D.5493>;
        <D.5492>:
        D.5494 = &MEM[(void *)"string.c" + 3B];
        D.5495 = *D.5494;
        D.5496 = (int) D.5495;
        D.5497 = __s2 + 3;
        D.5498 = *D.5497;
        D.5499 = (int) D.5498;
        __result = D.5496 - D.5499;
        <D.5493>:
        <D.5483>:
        <D.5473>:
      }
      D.5064 = __result;
    }
    iftmp.7 = -D.5064;
    goto <D.5500>;
    <D.5461>:
    D.5501 = strlen (s);
    D.5502 = D.5501 + 18446744073709551608;
    D.5503 = s + D.5502;
    iftmp.7 = __builtin_strcmp (D.5503, "string.c");
    <D.5500>:
    D.5065 = iftmp.7;
  }
  if (D.5065 != 0) goto <D.5504>; else goto <D.5505>;
  <D.5504>:
  D.5455 = FAILED ("This did not store the filename on G_STRLOC");
  return D.5455;
  <D.5505>:
  monoeg_g_free (s);
  D.5455 = 0B;
  return D.5455;
}


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

  if (str != 0B) goto <D.5507>; else goto <D.5508>;
  <D.5507>:
  D.5509 = __strdup (str);
  return D.5509;
  <D.5508>:
  D.5509 = 0B;
  return D.5509;
}


atoi (const char * __nptr)
{
  int D.5511;
  long int D.5512;

  D.5512 = strtol (__nptr, 0B, 10);
  D.5511 = (int) D.5512;
  return D.5511;
}


string_tests_init ()
{
  struct Test * D.5514;

  D.5514 = &string_tests;
  return D.5514;
}