test_shell_argv1 ()
{
  gchar * D.5274;
  int argc.0;
  int D.4960;
  int iftmp.1;
  int D.4959;
  gchar * * argv.2;
  char[5] * D.5294;
  unsigned char D.5295;
  int D.5296;
  unsigned char D.5297;
  int D.5298;
  _Bool D.5299;
  _Bool D.5300;
  _Bool D.5301;
  const unsigned char * D.5304;
  unsigned char D.5305;
  int D.5306;
  const unsigned char * D.5307;
  unsigned char D.5308;
  int D.5309;
  _Bool D.5310;
  _Bool D.5311;
  const unsigned char * D.5314;
  unsigned char D.5315;
  int D.5316;
  const unsigned char * D.5317;
  unsigned char D.5318;
  int D.5319;
  _Bool D.5320;
  _Bool D.5321;
  const unsigned char * D.5324;
  unsigned char D.5325;
  int D.5326;
  const unsigned char * D.5327;
  unsigned char D.5328;
  int D.5329;
  gchar * D.5331;
  int D.4969;
  int iftmp.3;
  int D.4968;
  char[5] * D.5337;
  unsigned char D.5338;
  int D.5339;
  unsigned char D.5340;
  int D.5341;
  _Bool D.5342;
  _Bool D.5343;
  _Bool D.5344;
  const unsigned char * D.5347;
  unsigned char D.5348;
  int D.5349;
  const unsigned char * D.5350;
  unsigned char D.5351;
  int D.5352;
  _Bool D.5353;
  _Bool D.5354;
  const unsigned char * D.5357;
  unsigned char D.5358;
  int D.5359;
  const unsigned char * D.5360;
  unsigned char D.5361;
  int D.5362;
  _Bool D.5363;
  _Bool D.5364;
  const unsigned char * D.5367;
  unsigned char D.5368;
  int D.5369;
  const unsigned char * D.5370;
  unsigned char D.5371;
  int D.5372;
  gchar * * D.5374;
  gchar * D.5375;
  int D.4978;
  int iftmp.4;
  int D.4977;
  unsigned char D.5385;
  int D.5386;
  _Bool D.5387;
  _Bool D.5388;
  _Bool D.5389;
  const unsigned char * D.5392;
  unsigned char D.5393;
  int D.5394;
  _Bool D.5395;
  _Bool D.5396;
  const unsigned char * D.5399;
  unsigned char D.5400;
  int D.5401;
  _Bool D.5402;
  _Bool D.5403;
  const unsigned char * D.5406;
  unsigned char D.5407;
  int D.5408;
  int D.4987;
  int iftmp.5;
  int D.4986;
  unsigned char D.5415;
  int D.5416;
  _Bool D.5417;
  _Bool D.5418;
  _Bool D.5419;
  const unsigned char * D.5422;
  unsigned char D.5423;
  int D.5424;
  _Bool D.5425;
  _Bool D.5426;
  const unsigned char * D.5429;
  unsigned char D.5430;
  int D.5431;
  _Bool D.5432;
  _Bool D.5433;
  const unsigned char * D.5436;
  unsigned char D.5437;
  int D.5438;
  struct GError * error.6;
  int D.4996;
  int iftmp.7;
  int D.4995;
  unsigned char D.5452;
  int D.5453;
  _Bool D.5454;
  _Bool D.5455;
  _Bool D.5456;
  const unsigned char * D.5459;
  unsigned char D.5460;
  int D.5461;
  _Bool D.5462;
  _Bool D.5463;
  const unsigned char * D.5466;
  unsigned char D.5467;
  int D.5468;
  _Bool D.5469;
  _Bool D.5470;
  const unsigned char * D.5473;
  unsigned char D.5474;
  int D.5475;
  int D.5005;
  int iftmp.8;
  int D.5004;
  char[1] * D.5482;
  unsigned char D.5483;
  int D.5484;
  unsigned char D.5485;
  int D.5486;
  _Bool D.5487;
  _Bool D.5488;
  _Bool D.5489;
  const unsigned char * D.5492;
  unsigned char D.5493;
  int D.5494;
  const unsigned char * D.5495;
  unsigned char D.5496;
  int D.5497;
  _Bool D.5498;
  _Bool D.5499;
  const unsigned char * D.5502;
  unsigned char D.5503;
  int D.5504;
  const unsigned char * D.5505;
  unsigned char D.5506;
  int D.5507;
  _Bool D.5508;
  _Bool D.5509;
  const unsigned char * D.5512;
  unsigned char D.5513;
  int D.5514;
  const unsigned char * D.5515;
  unsigned char D.5516;
  int D.5517;
  unsigned char D.5519;
  int D.5014;
  int iftmp.9;
  int D.5013;
  unsigned char D.5525;
  int D.5526;
  _Bool D.5527;
  _Bool D.5528;
  _Bool D.5529;
  const unsigned char * D.5532;
  unsigned char D.5533;
  int D.5534;
  _Bool D.5535;
  _Bool D.5536;
  const unsigned char * D.5539;
  unsigned char D.5540;
  int D.5541;
  _Bool D.5542;
  _Bool D.5543;
  const unsigned char * D.5546;
  unsigned char D.5547;
  int D.5548;
  gchar * * D.5550;
  gchar * D.5551;
  int D.5023;
  int iftmp.10;
  int D.5022;
  unsigned char D.5563;
  int D.5564;
  _Bool D.5565;
  _Bool D.5566;
  _Bool D.5567;
  const unsigned char * D.5570;
  unsigned char D.5571;
  int D.5572;
  _Bool D.5573;
  _Bool D.5574;
  const unsigned char * D.5577;
  unsigned char D.5578;
  int D.5579;
  _Bool D.5580;
  _Bool D.5581;
  const unsigned char * D.5584;
  unsigned char D.5585;
  int D.5586;
  int D.5032;
  int iftmp.11;
  int D.5031;
  unsigned char D.5593;
  int D.5594;
  _Bool D.5595;
  _Bool D.5596;
  _Bool D.5597;
  const unsigned char * D.5600;
  unsigned char D.5601;
  int D.5602;
  _Bool D.5603;
  _Bool D.5604;
  const unsigned char * D.5607;
  unsigned char D.5608;
  int D.5609;
  _Bool D.5610;
  _Bool D.5611;
  const unsigned char * D.5614;
  unsigned char D.5615;
  int D.5616;
  struct GError * error;
  gint argc;
  gchar * * argv;
  gboolean ret;

  try
    {
      ret = monoeg_g_shell_parse_argv ("", 0B, 0B, 0B);
      if (ret != 0) goto <D.5272>; else goto <D.5273>;
      <D.5272>:
      D.5274 = FAILED ("1. It should return FALSE");
      return D.5274;
      <D.5273>:
      ret = monoeg_g_shell_parse_argv ("hola", 0B, 0B, 0B);
      if (ret == 0) goto <D.5275>; else goto <D.5276>;
      <D.5275>:
      D.5274 = FAILED ("2. It should return TRUE");
      return D.5274;
      <D.5276>:
      argc = 0;
      ret = monoeg_g_shell_parse_argv ("hola", &argc, 0B, 0B);
      if (ret == 0) goto <D.5277>; else goto <D.5278>;
      <D.5277>:
      D.5274 = FAILED ("3. It should return TRUE");
      return D.5274;
      <D.5278>:
      argc.0 = argc;
      if (argc.0 != 1) goto <D.5280>; else goto <D.5281>;
      <D.5280>:
      argc.0 = argc;
      D.5274 = FAILED ("4. argc was %d", argc.0);
      return D.5274;
      <D.5281>:
      argc = 0;
      ret = monoeg_g_shell_parse_argv ("hola bola", &argc, 0B, 0B);
      if (ret == 0) goto <D.5282>; else goto <D.5283>;
      <D.5282>:
      D.5274 = FAILED ("5. It should return TRUE");
      return D.5274;
      <D.5283>:
      argc.0 = argc;
      if (argc.0 != 2) goto <D.5284>; else goto <D.5285>;
      <D.5284>:
      argc.0 = argc;
      D.5274 = FAILED ("6. argc was %d", argc.0);
      return D.5274;
      <D.5285>:
      argc = 0;
      ret = monoeg_g_shell_parse_argv ("hola bola", &argc, &argv, 0B);
      if (ret == 0) goto <D.5286>; else goto <D.5287>;
      <D.5286>:
      D.5274 = FAILED ("7. It should return TRUE");
      return D.5274;
      <D.5287>:
      argc.0 = argc;
      if (argc.0 != 2) goto <D.5288>; else goto <D.5289>;
      <D.5288>:
      argc.0 = argc;
      D.5274 = FAILED ("8. argc was %d", argc.0);
      return D.5274;
      <D.5289>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = *argv.2;
          D.5294 = "hola";
          D.5295 = MEM[(const unsigned char *)D.5294];
          D.5296 = (int) D.5295;
          D.5297 = *__s2;
          D.5298 = (int) D.5297;
          __result = D.5296 - D.5298;
          {
            D.5299 = __s2_len != 0;
            D.5300 = __result == 0;
            D.5301 = D.5299 & D.5300;
            if (D.5301 != 0) goto <D.5302>; else goto <D.5303>;
            <D.5302>:
            D.5304 = &MEM[(void *)"hola" + 1B];
            D.5305 = *D.5304;
            D.5306 = (int) D.5305;
            D.5307 = __s2 + 1;
            D.5308 = *D.5307;
            D.5309 = (int) D.5308;
            __result = D.5306 - D.5309;
            D.5310 = __s2_len > 1;
            D.5300 = __result == 0;
            D.5311 = D.5310 & D.5300;
            if (D.5311 != 0) goto <D.5312>; else goto <D.5313>;
            <D.5312>:
            D.5314 = &MEM[(void *)"hola" + 2B];
            D.5315 = *D.5314;
            D.5316 = (int) D.5315;
            D.5317 = __s2 + 2;
            D.5318 = *D.5317;
            D.5319 = (int) D.5318;
            __result = D.5316 - D.5319;
            D.5320 = __s2_len > 2;
            D.5300 = __result == 0;
            D.5321 = D.5320 & D.5300;
            if (D.5321 != 0) goto <D.5322>; else goto <D.5323>;
            <D.5322>:
            D.5324 = &MEM[(void *)"hola" + 3B];
            D.5325 = *D.5324;
            D.5326 = (int) D.5325;
            D.5327 = __s2 + 3;
            D.5328 = *D.5327;
            D.5329 = (int) D.5328;
            __result = D.5326 - D.5329;
            <D.5323>:
            <D.5313>:
            <D.5303>:
          }
          D.4959 = __result;
        }
        iftmp.1 = -D.4959;
        goto <D.5330>;
        <D.5292>:
        argv.2 = argv;
        D.5331 = *argv.2;
        iftmp.1 = __builtin_strcmp (D.5331, "hola");
        <D.5330>:
        D.4960 = iftmp.1;
      }
      if (D.4960 != 0) goto <D.5332>; else goto <D.5333>;
      <D.5332>:
      argv.2 = argv;
      D.5331 = *argv.2;
      D.5274 = FAILED ("9. argv[0] was %s", D.5331);
      return D.5274;
      <D.5333>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = MEM[(gchar * *)argv.2 + 8B];
          D.5337 = "bola";
          D.5338 = MEM[(const unsigned char *)D.5337];
          D.5339 = (int) D.5338;
          D.5340 = *__s2;
          D.5341 = (int) D.5340;
          __result = D.5339 - D.5341;
          {
            D.5342 = __s2_len != 0;
            D.5343 = __result == 0;
            D.5344 = D.5342 & D.5343;
            if (D.5344 != 0) goto <D.5345>; else goto <D.5346>;
            <D.5345>:
            D.5347 = &MEM[(void *)"bola" + 1B];
            D.5348 = *D.5347;
            D.5349 = (int) D.5348;
            D.5350 = __s2 + 1;
            D.5351 = *D.5350;
            D.5352 = (int) D.5351;
            __result = D.5349 - D.5352;
            D.5353 = __s2_len > 1;
            D.5343 = __result == 0;
            D.5354 = D.5353 & D.5343;
            if (D.5354 != 0) goto <D.5355>; else goto <D.5356>;
            <D.5355>:
            D.5357 = &MEM[(void *)"bola" + 2B];
            D.5358 = *D.5357;
            D.5359 = (int) D.5358;
            D.5360 = __s2 + 2;
            D.5361 = *D.5360;
            D.5362 = (int) D.5361;
            __result = D.5359 - D.5362;
            D.5363 = __s2_len > 2;
            D.5343 = __result == 0;
            D.5364 = D.5363 & D.5343;
            if (D.5364 != 0) goto <D.5365>; else goto <D.5366>;
            <D.5365>:
            D.5367 = &MEM[(void *)"bola" + 3B];
            D.5368 = *D.5367;
            D.5369 = (int) D.5368;
            D.5370 = __s2 + 3;
            D.5371 = *D.5370;
            D.5372 = (int) D.5371;
            __result = D.5369 - D.5372;
            <D.5366>:
            <D.5356>:
            <D.5346>:
          }
          D.4968 = __result;
        }
        iftmp.3 = -D.4968;
        goto <D.5373>;
        <D.5336>:
        argv.2 = argv;
        D.5374 = argv.2 + 8;
        D.5375 = *D.5374;
        iftmp.3 = __builtin_strcmp (D.5375, "bola");
        <D.5373>:
        D.4969 = iftmp.3;
      }
      if (D.4969 != 0) goto <D.5376>; else goto <D.5377>;
      <D.5376>:
      argv.2 = argv;
      D.5374 = argv.2 + 8;
      D.5375 = *D.5374;
      D.5274 = FAILED ("10. argv[1] was %s", D.5375);
      return D.5274;
      <D.5377>:
      argv.2 = argv;
      monoeg_g_strfreev (argv.2);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola      \'bola\'", &argc, &argv, &error);
      if (ret == 0) goto <D.5378>; else goto <D.5379>;
      <D.5378>:
      D.5274 = FAILED ("11. It should return TRUE");
      return D.5274;
      <D.5379>:
      argc.0 = argc;
      if (argc.0 != 2) goto <D.5380>; else goto <D.5381>;
      <D.5380>:
      argc.0 = argc;
      D.5274 = FAILED ("12. argc was %d expected 2", argc.0);
      return D.5274;
      <D.5381>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = *argv.2;
          D.5294 = "hola";
          D.5295 = MEM[(const unsigned char *)D.5294];
          D.5296 = (int) D.5295;
          D.5385 = *__s2;
          D.5386 = (int) D.5385;
          __result = D.5296 - D.5386;
          {
            D.5387 = __s2_len != 0;
            D.5388 = __result == 0;
            D.5389 = D.5387 & D.5388;
            if (D.5389 != 0) goto <D.5390>; else goto <D.5391>;
            <D.5390>:
            D.5304 = &MEM[(void *)"hola" + 1B];
            D.5305 = *D.5304;
            D.5306 = (int) D.5305;
            D.5392 = __s2 + 1;
            D.5393 = *D.5392;
            D.5394 = (int) D.5393;
            __result = D.5306 - D.5394;
            D.5395 = __s2_len > 1;
            D.5388 = __result == 0;
            D.5396 = D.5395 & D.5388;
            if (D.5396 != 0) goto <D.5397>; else goto <D.5398>;
            <D.5397>:
            D.5314 = &MEM[(void *)"hola" + 2B];
            D.5315 = *D.5314;
            D.5316 = (int) D.5315;
            D.5399 = __s2 + 2;
            D.5400 = *D.5399;
            D.5401 = (int) D.5400;
            __result = D.5316 - D.5401;
            D.5402 = __s2_len > 2;
            D.5388 = __result == 0;
            D.5403 = D.5402 & D.5388;
            if (D.5403 != 0) goto <D.5404>; else goto <D.5405>;
            <D.5404>:
            D.5324 = &MEM[(void *)"hola" + 3B];
            D.5325 = *D.5324;
            D.5326 = (int) D.5325;
            D.5406 = __s2 + 3;
            D.5407 = *D.5406;
            D.5408 = (int) D.5407;
            __result = D.5326 - D.5408;
            <D.5405>:
            <D.5398>:
            <D.5391>:
          }
          D.4977 = __result;
        }
        iftmp.4 = -D.4977;
        goto <D.5409>;
        <D.5384>:
        argv.2 = argv;
        D.5331 = *argv.2;
        iftmp.4 = __builtin_strcmp (D.5331, "hola");
        <D.5409>:
        D.4978 = iftmp.4;
      }
      if (D.4978 != 0) goto <D.5410>; else goto <D.5411>;
      <D.5410>:
      argv.2 = argv;
      D.5331 = *argv.2;
      D.5274 = FAILED ("13. argv[0] was %s", D.5331);
      return D.5274;
      <D.5411>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = MEM[(gchar * *)argv.2 + 8B];
          D.5337 = "bola";
          D.5338 = MEM[(const unsigned char *)D.5337];
          D.5339 = (int) D.5338;
          D.5415 = *__s2;
          D.5416 = (int) D.5415;
          __result = D.5339 - D.5416;
          {
            D.5417 = __s2_len != 0;
            D.5418 = __result == 0;
            D.5419 = D.5417 & D.5418;
            if (D.5419 != 0) goto <D.5420>; else goto <D.5421>;
            <D.5420>:
            D.5347 = &MEM[(void *)"bola" + 1B];
            D.5348 = *D.5347;
            D.5349 = (int) D.5348;
            D.5422 = __s2 + 1;
            D.5423 = *D.5422;
            D.5424 = (int) D.5423;
            __result = D.5349 - D.5424;
            D.5425 = __s2_len > 1;
            D.5418 = __result == 0;
            D.5426 = D.5425 & D.5418;
            if (D.5426 != 0) goto <D.5427>; else goto <D.5428>;
            <D.5427>:
            D.5357 = &MEM[(void *)"bola" + 2B];
            D.5358 = *D.5357;
            D.5359 = (int) D.5358;
            D.5429 = __s2 + 2;
            D.5430 = *D.5429;
            D.5431 = (int) D.5430;
            __result = D.5359 - D.5431;
            D.5432 = __s2_len > 2;
            D.5418 = __result == 0;
            D.5433 = D.5432 & D.5418;
            if (D.5433 != 0) goto <D.5434>; else goto <D.5435>;
            <D.5434>:
            D.5367 = &MEM[(void *)"bola" + 3B];
            D.5368 = *D.5367;
            D.5369 = (int) D.5368;
            D.5436 = __s2 + 3;
            D.5437 = *D.5436;
            D.5438 = (int) D.5437;
            __result = D.5369 - D.5438;
            <D.5435>:
            <D.5428>:
            <D.5421>:
          }
          D.4986 = __result;
        }
        iftmp.5 = -D.4986;
        goto <D.5439>;
        <D.5414>:
        argv.2 = argv;
        D.5374 = argv.2 + 8;
        D.5375 = *D.5374;
        iftmp.5 = __builtin_strcmp (D.5375, "bola");
        <D.5439>:
        D.4987 = iftmp.5;
      }
      if (D.4987 != 0) goto <D.5440>; else goto <D.5441>;
      <D.5440>:
      argv.2 = argv;
      D.5374 = argv.2 + 8;
      D.5375 = *D.5374;
      D.5274 = FAILED ("14. argv[1] was %s", D.5375);
      return D.5274;
      <D.5441>:
      error.6 = error;
      if (error.6 != 0B) goto <D.5443>; else goto <D.5444>;
      <D.5443>:
      D.5274 = FAILED ("15. error is not null");
      return D.5274;
      <D.5444>:
      argv.2 = argv;
      monoeg_g_strfreev (argv.2);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola    \'\'  \'bola\'", &argc, &argv, &error);
      if (ret == 0) goto <D.5445>; else goto <D.5446>;
      <D.5445>:
      D.5274 = FAILED ("16. It should return TRUE");
      return D.5274;
      <D.5446>:
      argc.0 = argc;
      if (argc.0 != 3) goto <D.5447>; else goto <D.5448>;
      <D.5447>:
      argc.0 = argc;
      D.5274 = FAILED ("17. argc was %d expected 3", argc.0);
      return D.5274;
      <D.5448>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = *argv.2;
          D.5294 = "hola";
          D.5295 = MEM[(const unsigned char *)D.5294];
          D.5296 = (int) D.5295;
          D.5452 = *__s2;
          D.5453 = (int) D.5452;
          __result = D.5296 - D.5453;
          {
            D.5454 = __s2_len != 0;
            D.5455 = __result == 0;
            D.5456 = D.5454 & D.5455;
            if (D.5456 != 0) goto <D.5457>; else goto <D.5458>;
            <D.5457>:
            D.5304 = &MEM[(void *)"hola" + 1B];
            D.5305 = *D.5304;
            D.5306 = (int) D.5305;
            D.5459 = __s2 + 1;
            D.5460 = *D.5459;
            D.5461 = (int) D.5460;
            __result = D.5306 - D.5461;
            D.5462 = __s2_len > 1;
            D.5455 = __result == 0;
            D.5463 = D.5462 & D.5455;
            if (D.5463 != 0) goto <D.5464>; else goto <D.5465>;
            <D.5464>:
            D.5314 = &MEM[(void *)"hola" + 2B];
            D.5315 = *D.5314;
            D.5316 = (int) D.5315;
            D.5466 = __s2 + 2;
            D.5467 = *D.5466;
            D.5468 = (int) D.5467;
            __result = D.5316 - D.5468;
            D.5469 = __s2_len > 2;
            D.5455 = __result == 0;
            D.5470 = D.5469 & D.5455;
            if (D.5470 != 0) goto <D.5471>; else goto <D.5472>;
            <D.5471>:
            D.5324 = &MEM[(void *)"hola" + 3B];
            D.5325 = *D.5324;
            D.5326 = (int) D.5325;
            D.5473 = __s2 + 3;
            D.5474 = *D.5473;
            D.5475 = (int) D.5474;
            __result = D.5326 - D.5475;
            <D.5472>:
            <D.5465>:
            <D.5458>:
          }
          D.4995 = __result;
        }
        iftmp.7 = -D.4995;
        goto <D.5476>;
        <D.5451>:
        argv.2 = argv;
        D.5331 = *argv.2;
        iftmp.7 = __builtin_strcmp (D.5331, "hola");
        <D.5476>:
        D.4996 = iftmp.7;
      }
      if (D.4996 != 0) goto <D.5477>; else goto <D.5478>;
      <D.5477>:
      argv.2 = argv;
      D.5331 = *argv.2;
      D.5274 = FAILED ("18. argv[0] was %s", D.5331);
      return D.5274;
      <D.5478>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = MEM[(gchar * *)argv.2 + 8B];
          D.5482 = "";
          D.5483 = MEM[(const unsigned char *)D.5482];
          D.5484 = (int) D.5483;
          D.5485 = *__s2;
          D.5486 = (int) D.5485;
          __result = D.5484 - D.5486;
          {
            D.5487 = __s2_len != 0;
            D.5488 = __result == 0;
            D.5489 = D.5487 & D.5488;
            if (D.5489 != 0) goto <D.5490>; else goto <D.5491>;
            <D.5490>:
            D.5492 = &MEM[(void *)"" + 1B];
            D.5493 = *D.5492;
            D.5494 = (int) D.5493;
            D.5495 = __s2 + 1;
            D.5496 = *D.5495;
            D.5497 = (int) D.5496;
            __result = D.5494 - D.5497;
            D.5498 = __s2_len > 1;
            D.5488 = __result == 0;
            D.5499 = D.5498 & D.5488;
            if (D.5499 != 0) goto <D.5500>; else goto <D.5501>;
            <D.5500>:
            D.5502 = &MEM[(void *)"" + 2B];
            D.5503 = *D.5502;
            D.5504 = (int) D.5503;
            D.5505 = __s2 + 2;
            D.5506 = *D.5505;
            D.5507 = (int) D.5506;
            __result = D.5504 - D.5507;
            D.5508 = __s2_len > 2;
            D.5488 = __result == 0;
            D.5509 = D.5508 & D.5488;
            if (D.5509 != 0) goto <D.5510>; else goto <D.5511>;
            <D.5510>:
            D.5512 = &MEM[(void *)"" + 3B];
            D.5513 = *D.5512;
            D.5514 = (int) D.5513;
            D.5515 = __s2 + 3;
            D.5516 = *D.5515;
            D.5517 = (int) D.5516;
            __result = D.5514 - D.5517;
            <D.5511>:
            <D.5501>:
            <D.5491>:
          }
          D.5004 = __result;
        }
        iftmp.8 = -D.5004;
        goto <D.5518>;
        <D.5481>:
        argv.2 = argv;
        D.5374 = argv.2 + 8;
        D.5375 = *D.5374;
        D.5519 = MEM[(const unsigned char * {ref-all})D.5375];
        iftmp.8 = (int) D.5519;
        <D.5518>:
        D.5005 = iftmp.8;
      }
      if (D.5005 != 0) goto <D.5520>; else goto <D.5521>;
      <D.5520>:
      argv.2 = argv;
      D.5374 = argv.2 + 8;
      D.5375 = *D.5374;
      D.5274 = FAILED ("19. argv[2] was %s", D.5375);
      return D.5274;
      <D.5521>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = MEM[(gchar * *)argv.2 + 16B];
          D.5337 = "bola";
          D.5338 = MEM[(const unsigned char *)D.5337];
          D.5339 = (int) D.5338;
          D.5525 = *__s2;
          D.5526 = (int) D.5525;
          __result = D.5339 - D.5526;
          {
            D.5527 = __s2_len != 0;
            D.5528 = __result == 0;
            D.5529 = D.5527 & D.5528;
            if (D.5529 != 0) goto <D.5530>; else goto <D.5531>;
            <D.5530>:
            D.5347 = &MEM[(void *)"bola" + 1B];
            D.5348 = *D.5347;
            D.5349 = (int) D.5348;
            D.5532 = __s2 + 1;
            D.5533 = *D.5532;
            D.5534 = (int) D.5533;
            __result = D.5349 - D.5534;
            D.5535 = __s2_len > 1;
            D.5528 = __result == 0;
            D.5536 = D.5535 & D.5528;
            if (D.5536 != 0) goto <D.5537>; else goto <D.5538>;
            <D.5537>:
            D.5357 = &MEM[(void *)"bola" + 2B];
            D.5358 = *D.5357;
            D.5359 = (int) D.5358;
            D.5539 = __s2 + 2;
            D.5540 = *D.5539;
            D.5541 = (int) D.5540;
            __result = D.5359 - D.5541;
            D.5542 = __s2_len > 2;
            D.5528 = __result == 0;
            D.5543 = D.5542 & D.5528;
            if (D.5543 != 0) goto <D.5544>; else goto <D.5545>;
            <D.5544>:
            D.5367 = &MEM[(void *)"bola" + 3B];
            D.5368 = *D.5367;
            D.5369 = (int) D.5368;
            D.5546 = __s2 + 3;
            D.5547 = *D.5546;
            D.5548 = (int) D.5547;
            __result = D.5369 - D.5548;
            <D.5545>:
            <D.5538>:
            <D.5531>:
          }
          D.5013 = __result;
        }
        iftmp.9 = -D.5013;
        goto <D.5549>;
        <D.5524>:
        argv.2 = argv;
        D.5550 = argv.2 + 16;
        D.5551 = *D.5550;
        iftmp.9 = __builtin_strcmp (D.5551, "bola");
        <D.5549>:
        D.5014 = iftmp.9;
      }
      if (D.5014 != 0) goto <D.5552>; else goto <D.5553>;
      <D.5552>:
      argv.2 = argv;
      D.5550 = argv.2 + 16;
      D.5551 = *D.5550;
      D.5274 = FAILED ("19. argv[2] was %s", D.5551);
      return D.5274;
      <D.5553>:
      error.6 = error;
      if (error.6 != 0B) goto <D.5554>; else goto <D.5555>;
      <D.5554>:
      D.5274 = FAILED ("20. error is not null");
      return D.5274;
      <D.5555>:
      argv.2 = argv;
      monoeg_g_strfreev (argv.2);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola\'\' bola", &argc, &argv, &error);
      if (ret == 0) goto <D.5556>; else goto <D.5557>;
      <D.5556>:
      D.5274 = FAILED ("21. It should return TRUE");
      return D.5274;
      <D.5557>:
      argc.0 = argc;
      if (argc.0 != 2) goto <D.5558>; else goto <D.5559>;
      <D.5558>:
      argc.0 = argc;
      D.5274 = FAILED ("22. argc was %d expected 2", argc.0);
      return D.5274;
      <D.5559>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = *argv.2;
          D.5294 = "hola";
          D.5295 = MEM[(const unsigned char *)D.5294];
          D.5296 = (int) D.5295;
          D.5563 = *__s2;
          D.5564 = (int) D.5563;
          __result = D.5296 - D.5564;
          {
            D.5565 = __s2_len != 0;
            D.5566 = __result == 0;
            D.5567 = D.5565 & D.5566;
            if (D.5567 != 0) goto <D.5568>; else goto <D.5569>;
            <D.5568>:
            D.5304 = &MEM[(void *)"hola" + 1B];
            D.5305 = *D.5304;
            D.5306 = (int) D.5305;
            D.5570 = __s2 + 1;
            D.5571 = *D.5570;
            D.5572 = (int) D.5571;
            __result = D.5306 - D.5572;
            D.5573 = __s2_len > 1;
            D.5566 = __result == 0;
            D.5574 = D.5573 & D.5566;
            if (D.5574 != 0) goto <D.5575>; else goto <D.5576>;
            <D.5575>:
            D.5314 = &MEM[(void *)"hola" + 2B];
            D.5315 = *D.5314;
            D.5316 = (int) D.5315;
            D.5577 = __s2 + 2;
            D.5578 = *D.5577;
            D.5579 = (int) D.5578;
            __result = D.5316 - D.5579;
            D.5580 = __s2_len > 2;
            D.5566 = __result == 0;
            D.5581 = D.5580 & D.5566;
            if (D.5581 != 0) goto <D.5582>; else goto <D.5583>;
            <D.5582>:
            D.5324 = &MEM[(void *)"hola" + 3B];
            D.5325 = *D.5324;
            D.5326 = (int) D.5325;
            D.5584 = __s2 + 3;
            D.5585 = *D.5584;
            D.5586 = (int) D.5585;
            __result = D.5326 - D.5586;
            <D.5583>:
            <D.5576>:
            <D.5569>:
          }
          D.5022 = __result;
        }
        iftmp.10 = -D.5022;
        goto <D.5587>;
        <D.5562>:
        argv.2 = argv;
        D.5331 = *argv.2;
        iftmp.10 = __builtin_strcmp (D.5331, "hola");
        <D.5587>:
        D.5023 = iftmp.10;
      }
      if (D.5023 != 0) goto <D.5588>; else goto <D.5589>;
      <D.5588>:
      argv.2 = argv;
      D.5331 = *argv.2;
      D.5274 = FAILED ("23. argv[0] was %s", D.5331);
      return D.5274;
      <D.5589>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.2 = argv;
          __s2 = MEM[(gchar * *)argv.2 + 8B];
          D.5337 = "bola";
          D.5338 = MEM[(const unsigned char *)D.5337];
          D.5339 = (int) D.5338;
          D.5593 = *__s2;
          D.5594 = (int) D.5593;
          __result = D.5339 - D.5594;
          {
            D.5595 = __s2_len != 0;
            D.5596 = __result == 0;
            D.5597 = D.5595 & D.5596;
            if (D.5597 != 0) goto <D.5598>; else goto <D.5599>;
            <D.5598>:
            D.5347 = &MEM[(void *)"bola" + 1B];
            D.5348 = *D.5347;
            D.5349 = (int) D.5348;
            D.5600 = __s2 + 1;
            D.5601 = *D.5600;
            D.5602 = (int) D.5601;
            __result = D.5349 - D.5602;
            D.5603 = __s2_len > 1;
            D.5596 = __result == 0;
            D.5604 = D.5603 & D.5596;
            if (D.5604 != 0) goto <D.5605>; else goto <D.5606>;
            <D.5605>:
            D.5357 = &MEM[(void *)"bola" + 2B];
            D.5358 = *D.5357;
            D.5359 = (int) D.5358;
            D.5607 = __s2 + 2;
            D.5608 = *D.5607;
            D.5609 = (int) D.5608;
            __result = D.5359 - D.5609;
            D.5610 = __s2_len > 2;
            D.5596 = __result == 0;
            D.5611 = D.5610 & D.5596;
            if (D.5611 != 0) goto <D.5612>; else goto <D.5613>;
            <D.5612>:
            D.5367 = &MEM[(void *)"bola" + 3B];
            D.5368 = *D.5367;
            D.5369 = (int) D.5368;
            D.5614 = __s2 + 3;
            D.5615 = *D.5614;
            D.5616 = (int) D.5615;
            __result = D.5369 - D.5616;
            <D.5613>:
            <D.5606>:
            <D.5599>:
          }
          D.5031 = __result;
        }
        iftmp.11 = -D.5031;
        goto <D.5617>;
        <D.5592>:
        argv.2 = argv;
        D.5374 = argv.2 + 8;
        D.5375 = *D.5374;
        iftmp.11 = __builtin_strcmp (D.5375, "bola");
        <D.5617>:
        D.5032 = iftmp.11;
      }
      if (D.5032 != 0) goto <D.5618>; else goto <D.5619>;
      <D.5618>:
      argv.2 = argv;
      D.5374 = argv.2 + 8;
      D.5375 = *D.5374;
      D.5274 = FAILED ("24. argv[2] was %s", D.5375);
      return D.5274;
      <D.5619>:
      error.6 = error;
      if (error.6 != 0B) goto <D.5620>; else goto <D.5621>;
      <D.5620>:
      D.5274 = FAILED ("25. error is not null");
      return D.5274;
      <D.5621>:
      D.5274 = 0B;
      return D.5274;
    }
  finally
    {
      error = {CLOBBER};
      argc = {CLOBBER};
      argv = {CLOBBER};
    }
}


test_shell_argv2 ()
{
  gchar * D.5626;
  int argc.12;
  int D.5047;
  int iftmp.13;
  int D.5046;
  gchar * * argv.14;
  char[5] * D.5634;
  unsigned char D.5635;
  int D.5636;
  unsigned char D.5637;
  int D.5638;
  _Bool D.5639;
  _Bool D.5640;
  _Bool D.5641;
  const unsigned char * D.5644;
  unsigned char D.5645;
  int D.5646;
  const unsigned char * D.5647;
  unsigned char D.5648;
  int D.5649;
  _Bool D.5650;
  _Bool D.5651;
  const unsigned char * D.5654;
  unsigned char D.5655;
  int D.5656;
  const unsigned char * D.5657;
  unsigned char D.5658;
  int D.5659;
  _Bool D.5660;
  _Bool D.5661;
  const unsigned char * D.5664;
  unsigned char D.5665;
  int D.5666;
  const unsigned char * D.5667;
  unsigned char D.5668;
  int D.5669;
  gchar * D.5671;
  int D.5056;
  int iftmp.15;
  int D.5055;
  char[5] * D.5677;
  unsigned char D.5678;
  int D.5679;
  unsigned char D.5680;
  int D.5681;
  _Bool D.5682;
  _Bool D.5683;
  _Bool D.5684;
  const unsigned char * D.5687;
  unsigned char D.5688;
  int D.5689;
  const unsigned char * D.5690;
  unsigned char D.5691;
  int D.5692;
  _Bool D.5693;
  _Bool D.5694;
  const unsigned char * D.5697;
  unsigned char D.5698;
  int D.5699;
  const unsigned char * D.5700;
  unsigned char D.5701;
  int D.5702;
  _Bool D.5703;
  _Bool D.5704;
  const unsigned char * D.5707;
  unsigned char D.5708;
  int D.5709;
  const unsigned char * D.5710;
  unsigned char D.5711;
  int D.5712;
  gchar * * D.5714;
  gchar * D.5715;
  struct GError * error.16;
  int D.5065;
  int iftmp.17;
  int D.5064;
  unsigned char D.5728;
  int D.5729;
  _Bool D.5730;
  _Bool D.5731;
  _Bool D.5732;
  const unsigned char * D.5735;
  unsigned char D.5736;
  int D.5737;
  _Bool D.5738;
  _Bool D.5739;
  const unsigned char * D.5742;
  unsigned char D.5743;
  int D.5744;
  _Bool D.5745;
  _Bool D.5746;
  const unsigned char * D.5749;
  unsigned char D.5750;
  int D.5751;
  int D.5074;
  int iftmp.18;
  int D.5073;
  char[1] * D.5758;
  unsigned char D.5759;
  int D.5760;
  unsigned char D.5761;
  int D.5762;
  _Bool D.5763;
  _Bool D.5764;
  _Bool D.5765;
  const unsigned char * D.5768;
  unsigned char D.5769;
  int D.5770;
  const unsigned char * D.5771;
  unsigned char D.5772;
  int D.5773;
  _Bool D.5774;
  _Bool D.5775;
  const unsigned char * D.5778;
  unsigned char D.5779;
  int D.5780;
  const unsigned char * D.5781;
  unsigned char D.5782;
  int D.5783;
  _Bool D.5784;
  _Bool D.5785;
  const unsigned char * D.5788;
  unsigned char D.5789;
  int D.5790;
  const unsigned char * D.5791;
  unsigned char D.5792;
  int D.5793;
  unsigned char D.5795;
  int D.5083;
  int iftmp.19;
  int D.5082;
  char[6] * D.5801;
  unsigned char D.5802;
  int D.5803;
  unsigned char D.5804;
  int D.5805;
  _Bool D.5806;
  _Bool D.5807;
  _Bool D.5808;
  const unsigned char * D.5811;
  unsigned char D.5812;
  int D.5813;
  const unsigned char * D.5814;
  unsigned char D.5815;
  int D.5816;
  _Bool D.5817;
  _Bool D.5818;
  const unsigned char * D.5821;
  unsigned char D.5822;
  int D.5823;
  const unsigned char * D.5824;
  unsigned char D.5825;
  int D.5826;
  _Bool D.5827;
  _Bool D.5828;
  const unsigned char * D.5831;
  unsigned char D.5832;
  int D.5833;
  const unsigned char * D.5834;
  unsigned char D.5835;
  int D.5836;
  gchar * * D.5838;
  gchar * D.5839;
  int D.5092;
  int iftmp.20;
  int D.5091;
  unsigned char D.5851;
  int D.5852;
  _Bool D.5853;
  _Bool D.5854;
  _Bool D.5855;
  const unsigned char * D.5858;
  unsigned char D.5859;
  int D.5860;
  _Bool D.5861;
  _Bool D.5862;
  const unsigned char * D.5865;
  unsigned char D.5866;
  int D.5867;
  _Bool D.5868;
  _Bool D.5869;
  const unsigned char * D.5872;
  unsigned char D.5873;
  int D.5874;
  int D.5101;
  int iftmp.21;
  int D.5100;
  char[2] * D.5881;
  unsigned char D.5882;
  int D.5883;
  unsigned char D.5884;
  int D.5885;
  _Bool D.5886;
  _Bool D.5887;
  _Bool D.5888;
  const unsigned char * D.5891;
  unsigned char D.5892;
  int D.5893;
  const unsigned char * D.5894;
  unsigned char D.5895;
  int D.5896;
  _Bool D.5897;
  _Bool D.5898;
  const unsigned char * D.5901;
  unsigned char D.5902;
  int D.5903;
  const unsigned char * D.5904;
  unsigned char D.5905;
  int D.5906;
  _Bool D.5907;
  _Bool D.5908;
  const unsigned char * D.5911;
  unsigned char D.5912;
  int D.5913;
  const unsigned char * D.5914;
  unsigned char D.5915;
  int D.5916;
  int D.5110;
  int iftmp.22;
  int D.5109;
  unsigned char D.5923;
  int D.5924;
  _Bool D.5925;
  _Bool D.5926;
  _Bool D.5927;
  const unsigned char * D.5930;
  unsigned char D.5931;
  int D.5932;
  _Bool D.5933;
  _Bool D.5934;
  const unsigned char * D.5937;
  unsigned char D.5938;
  int D.5939;
  _Bool D.5940;
  _Bool D.5941;
  const unsigned char * D.5944;
  unsigned char D.5945;
  int D.5946;
  int D.5119;
  int iftmp.23;
  int D.5118;
  unsigned char D.5959;
  int D.5960;
  _Bool D.5961;
  _Bool D.5962;
  _Bool D.5963;
  const unsigned char * D.5966;
  unsigned char D.5967;
  int D.5968;
  _Bool D.5969;
  _Bool D.5970;
  const unsigned char * D.5973;
  unsigned char D.5974;
  int D.5975;
  _Bool D.5976;
  _Bool D.5977;
  const unsigned char * D.5980;
  unsigned char D.5981;
  int D.5982;
  int D.5128;
  int iftmp.24;
  int D.5127;
  unsigned char D.5989;
  int D.5990;
  _Bool D.5991;
  _Bool D.5992;
  _Bool D.5993;
  const unsigned char * D.5996;
  unsigned char D.5997;
  int D.5998;
  _Bool D.5999;
  _Bool D.6000;
  const unsigned char * D.6003;
  unsigned char D.6004;
  int D.6005;
  _Bool D.6006;
  _Bool D.6007;
  const unsigned char * D.6010;
  unsigned char D.6011;
  int D.6012;
  int D.5137;
  int iftmp.25;
  int D.5136;
  unsigned char D.6019;
  int D.6020;
  _Bool D.6021;
  _Bool D.6022;
  _Bool D.6023;
  const unsigned char * D.6026;
  unsigned char D.6027;
  int D.6028;
  _Bool D.6029;
  _Bool D.6030;
  const unsigned char * D.6033;
  unsigned char D.6034;
  int D.6035;
  _Bool D.6036;
  _Bool D.6037;
  const unsigned char * D.6040;
  unsigned char D.6041;
  int D.6042;
  struct GError * error;
  gint argc;
  gchar * * argv;
  gboolean ret;

  try
    {
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola      \"bola\"", &argc, &argv, &error);
      if (ret == 0) goto <D.5624>; else goto <D.5625>;
      <D.5624>:
      D.5626 = FAILED ("1. It should return TRUE");
      return D.5626;
      <D.5625>:
      argc.12 = argc;
      if (argc.12 != 2) goto <D.5628>; else goto <D.5629>;
      <D.5628>:
      argc.12 = argc;
      D.5626 = FAILED ("2. argc was %d expected 2", argc.12);
      return D.5626;
      <D.5629>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = *argv.14;
          D.5634 = "hola";
          D.5635 = MEM[(const unsigned char *)D.5634];
          D.5636 = (int) D.5635;
          D.5637 = *__s2;
          D.5638 = (int) D.5637;
          __result = D.5636 - D.5638;
          {
            D.5639 = __s2_len != 0;
            D.5640 = __result == 0;
            D.5641 = D.5639 & D.5640;
            if (D.5641 != 0) goto <D.5642>; else goto <D.5643>;
            <D.5642>:
            D.5644 = &MEM[(void *)"hola" + 1B];
            D.5645 = *D.5644;
            D.5646 = (int) D.5645;
            D.5647 = __s2 + 1;
            D.5648 = *D.5647;
            D.5649 = (int) D.5648;
            __result = D.5646 - D.5649;
            D.5650 = __s2_len > 1;
            D.5640 = __result == 0;
            D.5651 = D.5650 & D.5640;
            if (D.5651 != 0) goto <D.5652>; else goto <D.5653>;
            <D.5652>:
            D.5654 = &MEM[(void *)"hola" + 2B];
            D.5655 = *D.5654;
            D.5656 = (int) D.5655;
            D.5657 = __s2 + 2;
            D.5658 = *D.5657;
            D.5659 = (int) D.5658;
            __result = D.5656 - D.5659;
            D.5660 = __s2_len > 2;
            D.5640 = __result == 0;
            D.5661 = D.5660 & D.5640;
            if (D.5661 != 0) goto <D.5662>; else goto <D.5663>;
            <D.5662>:
            D.5664 = &MEM[(void *)"hola" + 3B];
            D.5665 = *D.5664;
            D.5666 = (int) D.5665;
            D.5667 = __s2 + 3;
            D.5668 = *D.5667;
            D.5669 = (int) D.5668;
            __result = D.5666 - D.5669;
            <D.5663>:
            <D.5653>:
            <D.5643>:
          }
          D.5046 = __result;
        }
        iftmp.13 = -D.5046;
        goto <D.5670>;
        <D.5632>:
        argv.14 = argv;
        D.5671 = *argv.14;
        iftmp.13 = __builtin_strcmp (D.5671, "hola");
        <D.5670>:
        D.5047 = iftmp.13;
      }
      if (D.5047 != 0) goto <D.5672>; else goto <D.5673>;
      <D.5672>:
      argv.14 = argv;
      D.5671 = *argv.14;
      D.5626 = FAILED ("3. argv[0] was %s", D.5671);
      return D.5626;
      <D.5673>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 8B];
          D.5677 = "bola";
          D.5678 = MEM[(const unsigned char *)D.5677];
          D.5679 = (int) D.5678;
          D.5680 = *__s2;
          D.5681 = (int) D.5680;
          __result = D.5679 - D.5681;
          {
            D.5682 = __s2_len != 0;
            D.5683 = __result == 0;
            D.5684 = D.5682 & D.5683;
            if (D.5684 != 0) goto <D.5685>; else goto <D.5686>;
            <D.5685>:
            D.5687 = &MEM[(void *)"bola" + 1B];
            D.5688 = *D.5687;
            D.5689 = (int) D.5688;
            D.5690 = __s2 + 1;
            D.5691 = *D.5690;
            D.5692 = (int) D.5691;
            __result = D.5689 - D.5692;
            D.5693 = __s2_len > 1;
            D.5683 = __result == 0;
            D.5694 = D.5693 & D.5683;
            if (D.5694 != 0) goto <D.5695>; else goto <D.5696>;
            <D.5695>:
            D.5697 = &MEM[(void *)"bola" + 2B];
            D.5698 = *D.5697;
            D.5699 = (int) D.5698;
            D.5700 = __s2 + 2;
            D.5701 = *D.5700;
            D.5702 = (int) D.5701;
            __result = D.5699 - D.5702;
            D.5703 = __s2_len > 2;
            D.5683 = __result == 0;
            D.5704 = D.5703 & D.5683;
            if (D.5704 != 0) goto <D.5705>; else goto <D.5706>;
            <D.5705>:
            D.5707 = &MEM[(void *)"bola" + 3B];
            D.5708 = *D.5707;
            D.5709 = (int) D.5708;
            D.5710 = __s2 + 3;
            D.5711 = *D.5710;
            D.5712 = (int) D.5711;
            __result = D.5709 - D.5712;
            <D.5706>:
            <D.5696>:
            <D.5686>:
          }
          D.5055 = __result;
        }
        iftmp.15 = -D.5055;
        goto <D.5713>;
        <D.5676>:
        argv.14 = argv;
        D.5714 = argv.14 + 8;
        D.5715 = *D.5714;
        iftmp.15 = __builtin_strcmp (D.5715, "bola");
        <D.5713>:
        D.5056 = iftmp.15;
      }
      if (D.5056 != 0) goto <D.5716>; else goto <D.5717>;
      <D.5716>:
      argv.14 = argv;
      D.5714 = argv.14 + 8;
      D.5715 = *D.5714;
      D.5626 = FAILED ("4. argv[1] was %s", D.5715);
      return D.5626;
      <D.5717>:
      error.16 = error;
      if (error.16 != 0B) goto <D.5719>; else goto <D.5720>;
      <D.5719>:
      D.5626 = FAILED ("5. error is not null");
      return D.5626;
      <D.5720>:
      argv.14 = argv;
      monoeg_g_strfreev (argv.14);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola    \"\"  \"bola \"", &argc, &argv, &error);
      if (ret == 0) goto <D.5721>; else goto <D.5722>;
      <D.5721>:
      D.5626 = FAILED ("6. It should return TRUE");
      return D.5626;
      <D.5722>:
      argc.12 = argc;
      if (argc.12 != 3) goto <D.5723>; else goto <D.5724>;
      <D.5723>:
      argc.12 = argc;
      D.5626 = FAILED ("7. argc was %d expected 3", argc.12);
      return D.5626;
      <D.5724>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = *argv.14;
          D.5634 = "hola";
          D.5635 = MEM[(const unsigned char *)D.5634];
          D.5636 = (int) D.5635;
          D.5728 = *__s2;
          D.5729 = (int) D.5728;
          __result = D.5636 - D.5729;
          {
            D.5730 = __s2_len != 0;
            D.5731 = __result == 0;
            D.5732 = D.5730 & D.5731;
            if (D.5732 != 0) goto <D.5733>; else goto <D.5734>;
            <D.5733>:
            D.5644 = &MEM[(void *)"hola" + 1B];
            D.5645 = *D.5644;
            D.5646 = (int) D.5645;
            D.5735 = __s2 + 1;
            D.5736 = *D.5735;
            D.5737 = (int) D.5736;
            __result = D.5646 - D.5737;
            D.5738 = __s2_len > 1;
            D.5731 = __result == 0;
            D.5739 = D.5738 & D.5731;
            if (D.5739 != 0) goto <D.5740>; else goto <D.5741>;
            <D.5740>:
            D.5654 = &MEM[(void *)"hola" + 2B];
            D.5655 = *D.5654;
            D.5656 = (int) D.5655;
            D.5742 = __s2 + 2;
            D.5743 = *D.5742;
            D.5744 = (int) D.5743;
            __result = D.5656 - D.5744;
            D.5745 = __s2_len > 2;
            D.5731 = __result == 0;
            D.5746 = D.5745 & D.5731;
            if (D.5746 != 0) goto <D.5747>; else goto <D.5748>;
            <D.5747>:
            D.5664 = &MEM[(void *)"hola" + 3B];
            D.5665 = *D.5664;
            D.5666 = (int) D.5665;
            D.5749 = __s2 + 3;
            D.5750 = *D.5749;
            D.5751 = (int) D.5750;
            __result = D.5666 - D.5751;
            <D.5748>:
            <D.5741>:
            <D.5734>:
          }
          D.5064 = __result;
        }
        iftmp.17 = -D.5064;
        goto <D.5752>;
        <D.5727>:
        argv.14 = argv;
        D.5671 = *argv.14;
        iftmp.17 = __builtin_strcmp (D.5671, "hola");
        <D.5752>:
        D.5065 = iftmp.17;
      }
      if (D.5065 != 0) goto <D.5753>; else goto <D.5754>;
      <D.5753>:
      argv.14 = argv;
      D.5671 = *argv.14;
      D.5626 = FAILED ("8. argv[0] was %s", D.5671);
      return D.5626;
      <D.5754>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 8B];
          D.5758 = "";
          D.5759 = MEM[(const unsigned char *)D.5758];
          D.5760 = (int) D.5759;
          D.5761 = *__s2;
          D.5762 = (int) D.5761;
          __result = D.5760 - D.5762;
          {
            D.5763 = __s2_len != 0;
            D.5764 = __result == 0;
            D.5765 = D.5763 & D.5764;
            if (D.5765 != 0) goto <D.5766>; else goto <D.5767>;
            <D.5766>:
            D.5768 = &MEM[(void *)"" + 1B];
            D.5769 = *D.5768;
            D.5770 = (int) D.5769;
            D.5771 = __s2 + 1;
            D.5772 = *D.5771;
            D.5773 = (int) D.5772;
            __result = D.5770 - D.5773;
            D.5774 = __s2_len > 1;
            D.5764 = __result == 0;
            D.5775 = D.5774 & D.5764;
            if (D.5775 != 0) goto <D.5776>; else goto <D.5777>;
            <D.5776>:
            D.5778 = &MEM[(void *)"" + 2B];
            D.5779 = *D.5778;
            D.5780 = (int) D.5779;
            D.5781 = __s2 + 2;
            D.5782 = *D.5781;
            D.5783 = (int) D.5782;
            __result = D.5780 - D.5783;
            D.5784 = __s2_len > 2;
            D.5764 = __result == 0;
            D.5785 = D.5784 & D.5764;
            if (D.5785 != 0) goto <D.5786>; else goto <D.5787>;
            <D.5786>:
            D.5788 = &MEM[(void *)"" + 3B];
            D.5789 = *D.5788;
            D.5790 = (int) D.5789;
            D.5791 = __s2 + 3;
            D.5792 = *D.5791;
            D.5793 = (int) D.5792;
            __result = D.5790 - D.5793;
            <D.5787>:
            <D.5777>:
            <D.5767>:
          }
          D.5073 = __result;
        }
        iftmp.18 = -D.5073;
        goto <D.5794>;
        <D.5757>:
        argv.14 = argv;
        D.5714 = argv.14 + 8;
        D.5715 = *D.5714;
        D.5795 = MEM[(const unsigned char * {ref-all})D.5715];
        iftmp.18 = (int) D.5795;
        <D.5794>:
        D.5074 = iftmp.18;
      }
      if (D.5074 != 0) goto <D.5796>; else goto <D.5797>;
      <D.5796>:
      argv.14 = argv;
      D.5714 = argv.14 + 8;
      D.5715 = *D.5714;
      D.5626 = FAILED ("9. argv[2] was %s", D.5715);
      return D.5626;
      <D.5797>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 16B];
          D.5801 = "bola ";
          D.5802 = MEM[(const unsigned char *)D.5801];
          D.5803 = (int) D.5802;
          D.5804 = *__s2;
          D.5805 = (int) D.5804;
          __result = D.5803 - D.5805;
          {
            D.5806 = __s2_len != 0;
            D.5807 = __result == 0;
            D.5808 = D.5806 & D.5807;
            if (D.5808 != 0) goto <D.5809>; else goto <D.5810>;
            <D.5809>:
            D.5811 = &MEM[(void *)"bola " + 1B];
            D.5812 = *D.5811;
            D.5813 = (int) D.5812;
            D.5814 = __s2 + 1;
            D.5815 = *D.5814;
            D.5816 = (int) D.5815;
            __result = D.5813 - D.5816;
            D.5817 = __s2_len > 1;
            D.5807 = __result == 0;
            D.5818 = D.5817 & D.5807;
            if (D.5818 != 0) goto <D.5819>; else goto <D.5820>;
            <D.5819>:
            D.5821 = &MEM[(void *)"bola " + 2B];
            D.5822 = *D.5821;
            D.5823 = (int) D.5822;
            D.5824 = __s2 + 2;
            D.5825 = *D.5824;
            D.5826 = (int) D.5825;
            __result = D.5823 - D.5826;
            D.5827 = __s2_len > 2;
            D.5807 = __result == 0;
            D.5828 = D.5827 & D.5807;
            if (D.5828 != 0) goto <D.5829>; else goto <D.5830>;
            <D.5829>:
            D.5831 = &MEM[(void *)"bola " + 3B];
            D.5832 = *D.5831;
            D.5833 = (int) D.5832;
            D.5834 = __s2 + 3;
            D.5835 = *D.5834;
            D.5836 = (int) D.5835;
            __result = D.5833 - D.5836;
            <D.5830>:
            <D.5820>:
            <D.5810>:
          }
          D.5082 = __result;
        }
        iftmp.19 = -D.5082;
        goto <D.5837>;
        <D.5800>:
        argv.14 = argv;
        D.5838 = argv.14 + 16;
        D.5839 = *D.5838;
        iftmp.19 = __builtin_strcmp (D.5839, "bola ");
        <D.5837>:
        D.5083 = iftmp.19;
      }
      if (D.5083 != 0) goto <D.5840>; else goto <D.5841>;
      <D.5840>:
      argv.14 = argv;
      D.5838 = argv.14 + 16;
      D.5839 = *D.5838;
      D.5626 = FAILED ("10. argv[2] was %s", D.5839);
      return D.5626;
      <D.5841>:
      error.16 = error;
      if (error.16 != 0B) goto <D.5842>; else goto <D.5843>;
      <D.5842>:
      D.5626 = FAILED ("11. error is not null");
      return D.5626;
      <D.5843>:
      argv.14 = argv;
      monoeg_g_strfreev (argv.14);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola\n\t    \"\t\"  \"bola \"", &argc, &argv, &error);
      if (ret == 0) goto <D.5844>; else goto <D.5845>;
      <D.5844>:
      D.5626 = FAILED ("10. It should return TRUE");
      return D.5626;
      <D.5845>:
      argc.12 = argc;
      if (argc.12 != 3) goto <D.5846>; else goto <D.5847>;
      <D.5846>:
      argc.12 = argc;
      D.5626 = FAILED ("11. argc was %d expected 3", argc.12);
      return D.5626;
      <D.5847>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = *argv.14;
          D.5634 = "hola";
          D.5635 = MEM[(const unsigned char *)D.5634];
          D.5636 = (int) D.5635;
          D.5851 = *__s2;
          D.5852 = (int) D.5851;
          __result = D.5636 - D.5852;
          {
            D.5853 = __s2_len != 0;
            D.5854 = __result == 0;
            D.5855 = D.5853 & D.5854;
            if (D.5855 != 0) goto <D.5856>; else goto <D.5857>;
            <D.5856>:
            D.5644 = &MEM[(void *)"hola" + 1B];
            D.5645 = *D.5644;
            D.5646 = (int) D.5645;
            D.5858 = __s2 + 1;
            D.5859 = *D.5858;
            D.5860 = (int) D.5859;
            __result = D.5646 - D.5860;
            D.5861 = __s2_len > 1;
            D.5854 = __result == 0;
            D.5862 = D.5861 & D.5854;
            if (D.5862 != 0) goto <D.5863>; else goto <D.5864>;
            <D.5863>:
            D.5654 = &MEM[(void *)"hola" + 2B];
            D.5655 = *D.5654;
            D.5656 = (int) D.5655;
            D.5865 = __s2 + 2;
            D.5866 = *D.5865;
            D.5867 = (int) D.5866;
            __result = D.5656 - D.5867;
            D.5868 = __s2_len > 2;
            D.5854 = __result == 0;
            D.5869 = D.5868 & D.5854;
            if (D.5869 != 0) goto <D.5870>; else goto <D.5871>;
            <D.5870>:
            D.5664 = &MEM[(void *)"hola" + 3B];
            D.5665 = *D.5664;
            D.5666 = (int) D.5665;
            D.5872 = __s2 + 3;
            D.5873 = *D.5872;
            D.5874 = (int) D.5873;
            __result = D.5666 - D.5874;
            <D.5871>:
            <D.5864>:
            <D.5857>:
          }
          D.5091 = __result;
        }
        iftmp.20 = -D.5091;
        goto <D.5875>;
        <D.5850>:
        argv.14 = argv;
        D.5671 = *argv.14;
        iftmp.20 = __builtin_strcmp (D.5671, "hola");
        <D.5875>:
        D.5092 = iftmp.20;
      }
      if (D.5092 != 0) goto <D.5876>; else goto <D.5877>;
      <D.5876>:
      argv.14 = argv;
      D.5671 = *argv.14;
      D.5626 = FAILED ("12. argv[0] was %s", D.5671);
      return D.5626;
      <D.5877>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 8B];
          D.5881 = "\t";
          D.5882 = MEM[(const unsigned char *)D.5881];
          D.5883 = (int) D.5882;
          D.5884 = *__s2;
          D.5885 = (int) D.5884;
          __result = D.5883 - D.5885;
          {
            D.5886 = __s2_len != 0;
            D.5887 = __result == 0;
            D.5888 = D.5886 & D.5887;
            if (D.5888 != 0) goto <D.5889>; else goto <D.5890>;
            <D.5889>:
            D.5891 = &MEM[(void *)"\t" + 1B];
            D.5892 = *D.5891;
            D.5893 = (int) D.5892;
            D.5894 = __s2 + 1;
            D.5895 = *D.5894;
            D.5896 = (int) D.5895;
            __result = D.5893 - D.5896;
            D.5897 = __s2_len > 1;
            D.5887 = __result == 0;
            D.5898 = D.5897 & D.5887;
            if (D.5898 != 0) goto <D.5899>; else goto <D.5900>;
            <D.5899>:
            D.5901 = &MEM[(void *)"\t" + 2B];
            D.5902 = *D.5901;
            D.5903 = (int) D.5902;
            D.5904 = __s2 + 2;
            D.5905 = *D.5904;
            D.5906 = (int) D.5905;
            __result = D.5903 - D.5906;
            D.5907 = __s2_len > 2;
            D.5887 = __result == 0;
            D.5908 = D.5907 & D.5887;
            if (D.5908 != 0) goto <D.5909>; else goto <D.5910>;
            <D.5909>:
            D.5911 = &MEM[(void *)"\t" + 3B];
            D.5912 = *D.5911;
            D.5913 = (int) D.5912;
            D.5914 = __s2 + 3;
            D.5915 = *D.5914;
            D.5916 = (int) D.5915;
            __result = D.5913 - D.5916;
            <D.5910>:
            <D.5900>:
            <D.5890>:
          }
          D.5100 = __result;
        }
        iftmp.21 = -D.5100;
        goto <D.5917>;
        <D.5880>:
        argv.14 = argv;
        D.5714 = argv.14 + 8;
        D.5715 = *D.5714;
        iftmp.21 = __builtin_strcmp (D.5715, "\t");
        <D.5917>:
        D.5101 = iftmp.21;
      }
      if (D.5101 != 0) goto <D.5918>; else goto <D.5919>;
      <D.5918>:
      argv.14 = argv;
      D.5714 = argv.14 + 8;
      D.5715 = *D.5714;
      D.5626 = FAILED ("13. argv[2] was %s", D.5715);
      return D.5626;
      <D.5919>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 16B];
          D.5801 = "bola ";
          D.5802 = MEM[(const unsigned char *)D.5801];
          D.5803 = (int) D.5802;
          D.5923 = *__s2;
          D.5924 = (int) D.5923;
          __result = D.5803 - D.5924;
          {
            D.5925 = __s2_len != 0;
            D.5926 = __result == 0;
            D.5927 = D.5925 & D.5926;
            if (D.5927 != 0) goto <D.5928>; else goto <D.5929>;
            <D.5928>:
            D.5811 = &MEM[(void *)"bola " + 1B];
            D.5812 = *D.5811;
            D.5813 = (int) D.5812;
            D.5930 = __s2 + 1;
            D.5931 = *D.5930;
            D.5932 = (int) D.5931;
            __result = D.5813 - D.5932;
            D.5933 = __s2_len > 1;
            D.5926 = __result == 0;
            D.5934 = D.5933 & D.5926;
            if (D.5934 != 0) goto <D.5935>; else goto <D.5936>;
            <D.5935>:
            D.5821 = &MEM[(void *)"bola " + 2B];
            D.5822 = *D.5821;
            D.5823 = (int) D.5822;
            D.5937 = __s2 + 2;
            D.5938 = *D.5937;
            D.5939 = (int) D.5938;
            __result = D.5823 - D.5939;
            D.5940 = __s2_len > 2;
            D.5926 = __result == 0;
            D.5941 = D.5940 & D.5926;
            if (D.5941 != 0) goto <D.5942>; else goto <D.5943>;
            <D.5942>:
            D.5831 = &MEM[(void *)"bola " + 3B];
            D.5832 = *D.5831;
            D.5833 = (int) D.5832;
            D.5944 = __s2 + 3;
            D.5945 = *D.5944;
            D.5946 = (int) D.5945;
            __result = D.5833 - D.5946;
            <D.5943>:
            <D.5936>:
            <D.5929>:
          }
          D.5109 = __result;
        }
        iftmp.22 = -D.5109;
        goto <D.5947>;
        <D.5922>:
        argv.14 = argv;
        D.5838 = argv.14 + 16;
        D.5839 = *D.5838;
        iftmp.22 = __builtin_strcmp (D.5839, "bola ");
        <D.5947>:
        D.5110 = iftmp.22;
      }
      if (D.5110 != 0) goto <D.5948>; else goto <D.5949>;
      <D.5948>:
      argv.14 = argv;
      D.5838 = argv.14 + 16;
      D.5839 = *D.5838;
      D.5626 = FAILED ("14. argv[2] was %s", D.5839);
      return D.5626;
      <D.5949>:
      error.16 = error;
      if (error.16 != 0B) goto <D.5950>; else goto <D.5951>;
      <D.5950>:
      D.5626 = FAILED ("15. error is not null");
      return D.5626;
      <D.5951>:
      argv.14 = argv;
      monoeg_g_strfreev (argv.14);
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola\n\t  \\\n  \"\t\"  \"bola \"", &argc, &argv, &error);
      if (ret == 0) goto <D.5952>; else goto <D.5953>;
      <D.5952>:
      D.5626 = FAILED ("16. It should return TRUE");
      return D.5626;
      <D.5953>:
      argc.12 = argc;
      if (argc.12 != 3) goto <D.5954>; else goto <D.5955>;
      <D.5954>:
      argc.12 = argc;
      D.5626 = FAILED ("17. argc was %d expected 3", argc.12);
      return D.5626;
      <D.5955>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = *argv.14;
          D.5634 = "hola";
          D.5635 = MEM[(const unsigned char *)D.5634];
          D.5636 = (int) D.5635;
          D.5959 = *__s2;
          D.5960 = (int) D.5959;
          __result = D.5636 - D.5960;
          {
            D.5961 = __s2_len != 0;
            D.5962 = __result == 0;
            D.5963 = D.5961 & D.5962;
            if (D.5963 != 0) goto <D.5964>; else goto <D.5965>;
            <D.5964>:
            D.5644 = &MEM[(void *)"hola" + 1B];
            D.5645 = *D.5644;
            D.5646 = (int) D.5645;
            D.5966 = __s2 + 1;
            D.5967 = *D.5966;
            D.5968 = (int) D.5967;
            __result = D.5646 - D.5968;
            D.5969 = __s2_len > 1;
            D.5962 = __result == 0;
            D.5970 = D.5969 & D.5962;
            if (D.5970 != 0) goto <D.5971>; else goto <D.5972>;
            <D.5971>:
            D.5654 = &MEM[(void *)"hola" + 2B];
            D.5655 = *D.5654;
            D.5656 = (int) D.5655;
            D.5973 = __s2 + 2;
            D.5974 = *D.5973;
            D.5975 = (int) D.5974;
            __result = D.5656 - D.5975;
            D.5976 = __s2_len > 2;
            D.5962 = __result == 0;
            D.5977 = D.5976 & D.5962;
            if (D.5977 != 0) goto <D.5978>; else goto <D.5979>;
            <D.5978>:
            D.5664 = &MEM[(void *)"hola" + 3B];
            D.5665 = *D.5664;
            D.5666 = (int) D.5665;
            D.5980 = __s2 + 3;
            D.5981 = *D.5980;
            D.5982 = (int) D.5981;
            __result = D.5666 - D.5982;
            <D.5979>:
            <D.5972>:
            <D.5965>:
          }
          D.5118 = __result;
        }
        iftmp.23 = -D.5118;
        goto <D.5983>;
        <D.5958>:
        argv.14 = argv;
        D.5671 = *argv.14;
        iftmp.23 = __builtin_strcmp (D.5671, "hola");
        <D.5983>:
        D.5119 = iftmp.23;
      }
      if (D.5119 != 0) goto <D.5984>; else goto <D.5985>;
      <D.5984>:
      argv.14 = argv;
      D.5671 = *argv.14;
      D.5626 = FAILED ("18. argv[0] was %s", D.5671);
      return D.5626;
      <D.5985>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 8B];
          D.5881 = "\t";
          D.5882 = MEM[(const unsigned char *)D.5881];
          D.5883 = (int) D.5882;
          D.5989 = *__s2;
          D.5990 = (int) D.5989;
          __result = D.5883 - D.5990;
          {
            D.5991 = __s2_len != 0;
            D.5992 = __result == 0;
            D.5993 = D.5991 & D.5992;
            if (D.5993 != 0) goto <D.5994>; else goto <D.5995>;
            <D.5994>:
            D.5891 = &MEM[(void *)"\t" + 1B];
            D.5892 = *D.5891;
            D.5893 = (int) D.5892;
            D.5996 = __s2 + 1;
            D.5997 = *D.5996;
            D.5998 = (int) D.5997;
            __result = D.5893 - D.5998;
            D.5999 = __s2_len > 1;
            D.5992 = __result == 0;
            D.6000 = D.5999 & D.5992;
            if (D.6000 != 0) goto <D.6001>; else goto <D.6002>;
            <D.6001>:
            D.5901 = &MEM[(void *)"\t" + 2B];
            D.5902 = *D.5901;
            D.5903 = (int) D.5902;
            D.6003 = __s2 + 2;
            D.6004 = *D.6003;
            D.6005 = (int) D.6004;
            __result = D.5903 - D.6005;
            D.6006 = __s2_len > 2;
            D.5992 = __result == 0;
            D.6007 = D.6006 & D.5992;
            if (D.6007 != 0) goto <D.6008>; else goto <D.6009>;
            <D.6008>:
            D.5911 = &MEM[(void *)"\t" + 3B];
            D.5912 = *D.5911;
            D.5913 = (int) D.5912;
            D.6010 = __s2 + 3;
            D.6011 = *D.6010;
            D.6012 = (int) D.6011;
            __result = D.5913 - D.6012;
            <D.6009>:
            <D.6002>:
            <D.5995>:
          }
          D.5127 = __result;
        }
        iftmp.24 = -D.5127;
        goto <D.6013>;
        <D.5988>:
        argv.14 = argv;
        D.5714 = argv.14 + 8;
        D.5715 = *D.5714;
        iftmp.24 = __builtin_strcmp (D.5715, "\t");
        <D.6013>:
        D.5128 = iftmp.24;
      }
      if (D.5128 != 0) goto <D.6014>; else goto <D.6015>;
      <D.6014>:
      argv.14 = argv;
      D.5714 = argv.14 + 8;
      D.5715 = *D.5714;
      D.5626 = FAILED ("19. argv[2] was %s", D.5715);
      return D.5626;
      <D.6015>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.14 = argv;
          __s2 = MEM[(gchar * *)argv.14 + 16B];
          D.5801 = "bola ";
          D.5802 = MEM[(const unsigned char *)D.5801];
          D.5803 = (int) D.5802;
          D.6019 = *__s2;
          D.6020 = (int) D.6019;
          __result = D.5803 - D.6020;
          {
            D.6021 = __s2_len != 0;
            D.6022 = __result == 0;
            D.6023 = D.6021 & D.6022;
            if (D.6023 != 0) goto <D.6024>; else goto <D.6025>;
            <D.6024>:
            D.5811 = &MEM[(void *)"bola " + 1B];
            D.5812 = *D.5811;
            D.5813 = (int) D.5812;
            D.6026 = __s2 + 1;
            D.6027 = *D.6026;
            D.6028 = (int) D.6027;
            __result = D.5813 - D.6028;
            D.6029 = __s2_len > 1;
            D.6022 = __result == 0;
            D.6030 = D.6029 & D.6022;
            if (D.6030 != 0) goto <D.6031>; else goto <D.6032>;
            <D.6031>:
            D.5821 = &MEM[(void *)"bola " + 2B];
            D.5822 = *D.5821;
            D.5823 = (int) D.5822;
            D.6033 = __s2 + 2;
            D.6034 = *D.6033;
            D.6035 = (int) D.6034;
            __result = D.5823 - D.6035;
            D.6036 = __s2_len > 2;
            D.6022 = __result == 0;
            D.6037 = D.6036 & D.6022;
            if (D.6037 != 0) goto <D.6038>; else goto <D.6039>;
            <D.6038>:
            D.5831 = &MEM[(void *)"bola " + 3B];
            D.5832 = *D.5831;
            D.5833 = (int) D.5832;
            D.6040 = __s2 + 3;
            D.6041 = *D.6040;
            D.6042 = (int) D.6041;
            __result = D.5833 - D.6042;
            <D.6039>:
            <D.6032>:
            <D.6025>:
          }
          D.5136 = __result;
        }
        iftmp.25 = -D.5136;
        goto <D.6043>;
        <D.6018>:
        argv.14 = argv;
        D.5838 = argv.14 + 16;
        D.5839 = *D.5838;
        iftmp.25 = __builtin_strcmp (D.5839, "bola ");
        <D.6043>:
        D.5137 = iftmp.25;
      }
      if (D.5137 != 0) goto <D.6044>; else goto <D.6045>;
      <D.6044>:
      argv.14 = argv;
      D.5838 = argv.14 + 16;
      D.5839 = *D.5838;
      D.5626 = FAILED ("20. argv[2] was %s", D.5839);
      return D.5626;
      <D.6045>:
      error.16 = error;
      if (error.16 != 0B) goto <D.6046>; else goto <D.6047>;
      <D.6046>:
      D.5626 = FAILED ("21. error is not null");
      return D.5626;
      <D.6047>:
      argv.14 = argv;
      monoeg_g_strfreev (argv.14);
      D.5626 = 0B;
      return D.5626;
    }
  finally
    {
      error = {CLOBBER};
      argc = {CLOBBER};
      argv = {CLOBBER};
    }
}


test_shell_argv3 ()
{
  gchar * D.6052;
  int argc.26;
  gchar * * argv.27;
  gchar * D.6059;
  struct GError * error.28;
  int D.5152;
  int iftmp.29;
  int D.5151;
  char[5] * D.6070;
  unsigned char D.6071;
  int D.6072;
  unsigned char D.6073;
  int D.6074;
  _Bool D.6075;
  _Bool D.6076;
  _Bool D.6077;
  const unsigned char * D.6080;
  unsigned char D.6081;
  int D.6082;
  const unsigned char * D.6083;
  unsigned char D.6084;
  int D.6085;
  _Bool D.6086;
  _Bool D.6087;
  const unsigned char * D.6090;
  unsigned char D.6091;
  int D.6092;
  const unsigned char * D.6093;
  unsigned char D.6094;
  int D.6095;
  _Bool D.6096;
  _Bool D.6097;
  const unsigned char * D.6100;
  unsigned char D.6101;
  int D.6102;
  const unsigned char * D.6103;
  unsigned char D.6104;
  int D.6105;
  int D.5161;
  int iftmp.30;
  int D.5160;
  char[6] * D.6112;
  unsigned char D.6113;
  int D.6114;
  unsigned char D.6115;
  int D.6116;
  _Bool D.6117;
  _Bool D.6118;
  _Bool D.6119;
  const unsigned char * D.6122;
  unsigned char D.6123;
  int D.6124;
  const unsigned char * D.6125;
  unsigned char D.6126;
  int D.6127;
  _Bool D.6128;
  _Bool D.6129;
  const unsigned char * D.6132;
  unsigned char D.6133;
  int D.6134;
  const unsigned char * D.6135;
  unsigned char D.6136;
  int D.6137;
  _Bool D.6138;
  _Bool D.6139;
  const unsigned char * D.6142;
  unsigned char D.6143;
  int D.6144;
  const unsigned char * D.6145;
  unsigned char D.6146;
  int D.6147;
  gchar * * D.6149;
  gchar * D.6150;
  gchar * D.6157;
  int D.5170;
  int iftmp.31;
  int D.5169;
  unsigned char D.6163;
  int D.6164;
  _Bool D.6165;
  _Bool D.6166;
  _Bool D.6167;
  const unsigned char * D.6170;
  unsigned char D.6171;
  int D.6172;
  _Bool D.6173;
  _Bool D.6174;
  const unsigned char * D.6177;
  unsigned char D.6178;
  int D.6179;
  _Bool D.6180;
  _Bool D.6181;
  const unsigned char * D.6184;
  unsigned char D.6185;
  int D.6186;
  int D.5179;
  int iftmp.32;
  int D.5178;
  char[8] * D.6193;
  unsigned char D.6194;
  int D.6195;
  unsigned char D.6196;
  int D.6197;
  _Bool D.6198;
  _Bool D.6199;
  _Bool D.6200;
  const unsigned char * D.6203;
  unsigned char D.6204;
  int D.6205;
  const unsigned char * D.6206;
  unsigned char D.6207;
  int D.6208;
  _Bool D.6209;
  _Bool D.6210;
  const unsigned char * D.6213;
  unsigned char D.6214;
  int D.6215;
  const unsigned char * D.6216;
  unsigned char D.6217;
  int D.6218;
  _Bool D.6219;
  _Bool D.6220;
  const unsigned char * D.6223;
  unsigned char D.6224;
  int D.6225;
  const unsigned char * D.6226;
  unsigned char D.6227;
  int D.6228;
  struct GError * error;
  gint argc;
  gchar * * argv;
  gboolean ret;

  try
    {
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola      \"bola", &argc, &argv, &error);
      if (ret != 0) goto <D.6050>; else goto <D.6051>;
      <D.6050>:
      D.6052 = FAILED ("1. It should return FALSE");
      return D.6052;
      <D.6051>:
      argc.26 = argc;
      if (argc.26 != 0) goto <D.6054>; else goto <D.6055>;
      <D.6054>:
      argc.26 = argc;
      D.6052 = FAILED ("2. argc was %d expected 0", argc.26);
      return D.6052;
      <D.6055>:
      argv.27 = argv;
      if (argv.27 != 0B) goto <D.6057>; else goto <D.6058>;
      <D.6057>:
      argv.27 = argv;
      D.6059 = *argv.27;
      D.6052 = FAILED ("3. argv[0] was %s", D.6059);
      return D.6052;
      <D.6058>:
      error.28 = error;
      if (error.28 == 0B) goto <D.6061>; else goto <D.6062>;
      <D.6061>:
      D.6052 = FAILED ("4. error is null");
      return D.6052;
      <D.6062>:
      error.28 = error;
      monoeg_g_error_free (error.28);
      error = 0B;
      ret = monoeg_g_shell_parse_argv ("hola      \\\"bola", &argc, &argv, &error);
      if (ret == 0) goto <D.6063>; else goto <D.6064>;
      <D.6063>:
      D.6052 = FAILED ("5. It should return TRUE");
      return D.6052;
      <D.6064>:
      argc.26 = argc;
      if (argc.26 != 2) goto <D.6065>; else goto <D.6066>;
      <D.6065>:
      argc.26 = argc;
      D.6052 = FAILED ("6. argc was %d expected 2", argc.26);
      return D.6052;
      <D.6066>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.27 = argv;
          __s2 = *argv.27;
          D.6070 = "hola";
          D.6071 = MEM[(const unsigned char *)D.6070];
          D.6072 = (int) D.6071;
          D.6073 = *__s2;
          D.6074 = (int) D.6073;
          __result = D.6072 - D.6074;
          {
            D.6075 = __s2_len != 0;
            D.6076 = __result == 0;
            D.6077 = D.6075 & D.6076;
            if (D.6077 != 0) goto <D.6078>; else goto <D.6079>;
            <D.6078>:
            D.6080 = &MEM[(void *)"hola" + 1B];
            D.6081 = *D.6080;
            D.6082 = (int) D.6081;
            D.6083 = __s2 + 1;
            D.6084 = *D.6083;
            D.6085 = (int) D.6084;
            __result = D.6082 - D.6085;
            D.6086 = __s2_len > 1;
            D.6076 = __result == 0;
            D.6087 = D.6086 & D.6076;
            if (D.6087 != 0) goto <D.6088>; else goto <D.6089>;
            <D.6088>:
            D.6090 = &MEM[(void *)"hola" + 2B];
            D.6091 = *D.6090;
            D.6092 = (int) D.6091;
            D.6093 = __s2 + 2;
            D.6094 = *D.6093;
            D.6095 = (int) D.6094;
            __result = D.6092 - D.6095;
            D.6096 = __s2_len > 2;
            D.6076 = __result == 0;
            D.6097 = D.6096 & D.6076;
            if (D.6097 != 0) goto <D.6098>; else goto <D.6099>;
            <D.6098>:
            D.6100 = &MEM[(void *)"hola" + 3B];
            D.6101 = *D.6100;
            D.6102 = (int) D.6101;
            D.6103 = __s2 + 3;
            D.6104 = *D.6103;
            D.6105 = (int) D.6104;
            __result = D.6102 - D.6105;
            <D.6099>:
            <D.6089>:
            <D.6079>:
          }
          D.5151 = __result;
        }
        iftmp.29 = -D.5151;
        goto <D.6106>;
        <D.6069>:
        argv.27 = argv;
        D.6059 = *argv.27;
        iftmp.29 = __builtin_strcmp (D.6059, "hola");
        <D.6106>:
        D.5152 = iftmp.29;
      }
      if (D.5152 != 0) goto <D.6107>; else goto <D.6108>;
      <D.6107>:
      argv.27 = argv;
      D.6059 = *argv.27;
      D.6052 = FAILED ("18. argv[0] was %s", D.6059);
      return D.6052;
      <D.6108>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.27 = argv;
          __s2 = MEM[(gchar * *)argv.27 + 8B];
          D.6112 = "\"bola";
          D.6113 = MEM[(const unsigned char *)D.6112];
          D.6114 = (int) D.6113;
          D.6115 = *__s2;
          D.6116 = (int) D.6115;
          __result = D.6114 - D.6116;
          {
            D.6117 = __s2_len != 0;
            D.6118 = __result == 0;
            D.6119 = D.6117 & D.6118;
            if (D.6119 != 0) goto <D.6120>; else goto <D.6121>;
            <D.6120>:
            D.6122 = &MEM[(void *)"\"bola" + 1B];
            D.6123 = *D.6122;
            D.6124 = (int) D.6123;
            D.6125 = __s2 + 1;
            D.6126 = *D.6125;
            D.6127 = (int) D.6126;
            __result = D.6124 - D.6127;
            D.6128 = __s2_len > 1;
            D.6118 = __result == 0;
            D.6129 = D.6128 & D.6118;
            if (D.6129 != 0) goto <D.6130>; else goto <D.6131>;
            <D.6130>:
            D.6132 = &MEM[(void *)"\"bola" + 2B];
            D.6133 = *D.6132;
            D.6134 = (int) D.6133;
            D.6135 = __s2 + 2;
            D.6136 = *D.6135;
            D.6137 = (int) D.6136;
            __result = D.6134 - D.6137;
            D.6138 = __s2_len > 2;
            D.6118 = __result == 0;
            D.6139 = D.6138 & D.6118;
            if (D.6139 != 0) goto <D.6140>; else goto <D.6141>;
            <D.6140>:
            D.6142 = &MEM[(void *)"\"bola" + 3B];
            D.6143 = *D.6142;
            D.6144 = (int) D.6143;
            D.6145 = __s2 + 3;
            D.6146 = *D.6145;
            D.6147 = (int) D.6146;
            __result = D.6144 - D.6147;
            <D.6141>:
            <D.6131>:
            <D.6121>:
          }
          D.5160 = __result;
        }
        iftmp.30 = -D.5160;
        goto <D.6148>;
        <D.6111>:
        argv.27 = argv;
        D.6149 = argv.27 + 8;
        D.6150 = *D.6149;
        iftmp.30 = __builtin_strcmp (D.6150, "\"bola");
        <D.6148>:
        D.5161 = iftmp.30;
      }
      if (D.5161 != 0) goto <D.6151>; else goto <D.6152>;
      <D.6151>:
      argv.27 = argv;
      D.6149 = argv.27 + 8;
      D.6150 = *D.6149;
      D.6052 = FAILED ("18. argv[1] was %s", D.6150);
      return D.6052;
      <D.6152>:
      error.28 = error;
      if (error.28 != 0B) goto <D.6153>; else goto <D.6154>;
      <D.6153>:
      D.6052 = FAILED ("8. error is not null");
      return D.6052;
      <D.6154>:
      argv.27 = argv;
      monoeg_g_strfreev (argv.27);
      argv = 0B;
      argc = 0;
      ret = monoeg_g_shell_parse_argv ("hola      \"\n\\\'bola\"", &argc, &argv, &error);
      if (ret == 0) goto <D.6155>; else goto <D.6156>;
      <D.6155>:
      error.28 = error;
      D.6157 = error.28->message;
      D.6052 = FAILED ("9. It should return TRUE. %s", D.6157);
      return D.6052;
      <D.6156>:
      argc.26 = argc;
      if (argc.26 != 2) goto <D.6158>; else goto <D.6159>;
      <D.6158>:
      argc.26 = argc;
      D.6052 = FAILED ("10. argc was %d expected 2", argc.26);
      return D.6052;
      <D.6159>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.27 = argv;
          __s2 = *argv.27;
          D.6070 = "hola";
          D.6071 = MEM[(const unsigned char *)D.6070];
          D.6072 = (int) D.6071;
          D.6163 = *__s2;
          D.6164 = (int) D.6163;
          __result = D.6072 - D.6164;
          {
            D.6165 = __s2_len != 0;
            D.6166 = __result == 0;
            D.6167 = D.6165 & D.6166;
            if (D.6167 != 0) goto <D.6168>; else goto <D.6169>;
            <D.6168>:
            D.6080 = &MEM[(void *)"hola" + 1B];
            D.6081 = *D.6080;
            D.6082 = (int) D.6081;
            D.6170 = __s2 + 1;
            D.6171 = *D.6170;
            D.6172 = (int) D.6171;
            __result = D.6082 - D.6172;
            D.6173 = __s2_len > 1;
            D.6166 = __result == 0;
            D.6174 = D.6173 & D.6166;
            if (D.6174 != 0) goto <D.6175>; else goto <D.6176>;
            <D.6175>:
            D.6090 = &MEM[(void *)"hola" + 2B];
            D.6091 = *D.6090;
            D.6092 = (int) D.6091;
            D.6177 = __s2 + 2;
            D.6178 = *D.6177;
            D.6179 = (int) D.6178;
            __result = D.6092 - D.6179;
            D.6180 = __s2_len > 2;
            D.6166 = __result == 0;
            D.6181 = D.6180 & D.6166;
            if (D.6181 != 0) goto <D.6182>; else goto <D.6183>;
            <D.6182>:
            D.6100 = &MEM[(void *)"hola" + 3B];
            D.6101 = *D.6100;
            D.6102 = (int) D.6101;
            D.6184 = __s2 + 3;
            D.6185 = *D.6184;
            D.6186 = (int) D.6185;
            __result = D.6102 - D.6186;
            <D.6183>:
            <D.6176>:
            <D.6169>:
          }
          D.5169 = __result;
        }
        iftmp.31 = -D.5169;
        goto <D.6187>;
        <D.6162>:
        argv.27 = argv;
        D.6059 = *argv.27;
        iftmp.31 = __builtin_strcmp (D.6059, "hola");
        <D.6187>:
        D.5170 = iftmp.31;
      }
      if (D.5170 != 0) goto <D.6188>; else goto <D.6189>;
      <D.6188>:
      argv.27 = argv;
      D.6059 = *argv.27;
      D.6052 = FAILED ("11. argv[0] was %s", D.6059);
      return D.6052;
      <D.6189>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.27 = argv;
          __s2 = MEM[(gchar * *)argv.27 + 8B];
          D.6193 = "\n\\\'bola";
          D.6194 = MEM[(const unsigned char *)D.6193];
          D.6195 = (int) D.6194;
          D.6196 = *__s2;
          D.6197 = (int) D.6196;
          __result = D.6195 - D.6197;
          {
            D.6198 = __s2_len != 0;
            D.6199 = __result == 0;
            D.6200 = D.6198 & D.6199;
            if (D.6200 != 0) goto <D.6201>; else goto <D.6202>;
            <D.6201>:
            D.6203 = &MEM[(void *)"\n\\\'bola" + 1B];
            D.6204 = *D.6203;
            D.6205 = (int) D.6204;
            D.6206 = __s2 + 1;
            D.6207 = *D.6206;
            D.6208 = (int) D.6207;
            __result = D.6205 - D.6208;
            D.6209 = __s2_len > 1;
            D.6199 = __result == 0;
            D.6210 = D.6209 & D.6199;
            if (D.6210 != 0) goto <D.6211>; else goto <D.6212>;
            <D.6211>:
            D.6213 = &MEM[(void *)"\n\\\'bola" + 2B];
            D.6214 = *D.6213;
            D.6215 = (int) D.6214;
            D.6216 = __s2 + 2;
            D.6217 = *D.6216;
            D.6218 = (int) D.6217;
            __result = D.6215 - D.6218;
            D.6219 = __s2_len > 2;
            D.6199 = __result == 0;
            D.6220 = D.6219 & D.6199;
            if (D.6220 != 0) goto <D.6221>; else goto <D.6222>;
            <D.6221>:
            D.6223 = &MEM[(void *)"\n\\\'bola" + 3B];
            D.6224 = *D.6223;
            D.6225 = (int) D.6224;
            D.6226 = __s2 + 3;
            D.6227 = *D.6226;
            D.6228 = (int) D.6227;
            __result = D.6225 - D.6228;
            <D.6222>:
            <D.6212>:
            <D.6202>:
          }
          D.5178 = __result;
        }
        iftmp.32 = -D.5178;
        goto <D.6229>;
        <D.6192>:
        argv.27 = argv;
        D.6149 = argv.27 + 8;
        D.6150 = *D.6149;
        iftmp.32 = __builtin_strcmp (D.6150, "\n\\\'bola");
        <D.6229>:
        D.5179 = iftmp.32;
      }
      if (D.5179 != 0) goto <D.6230>; else goto <D.6231>;
      <D.6230>:
      argv.27 = argv;
      D.6149 = argv.27 + 8;
      D.6150 = *D.6149;
      D.6052 = FAILED ("12. argv[1] was %s", D.6150);
      return D.6052;
      <D.6231>:
      error.28 = error;
      if (error.28 != 0B) goto <D.6232>; else goto <D.6233>;
      <D.6232>:
      D.6052 = FAILED ("13. error is not null");
      return D.6052;
      <D.6233>:
      argv.27 = argv;
      monoeg_g_strfreev (argv.27);
      argv = 0B;
      argc = 0;
      D.6052 = 0B;
      return D.6052;
    }
  finally
    {
      error = {CLOBBER};
      argc = {CLOBBER};
      argv = {CLOBBER};
    }
}


test_shell_argv4 ()
{
  gchar * D.6238;
  int argc.33;
  gchar * * argv.34;
  struct GError * error.35;
  int D.5195;
  int iftmp.36;
  int D.5194;
  char[24] * D.6251;
  unsigned char D.6252;
  int D.6253;
  unsigned char D.6254;
  int D.6255;
  _Bool D.6256;
  _Bool D.6257;
  _Bool D.6258;
  const unsigned char * D.6261;
  unsigned char D.6262;
  int D.6263;
  const unsigned char * D.6264;
  unsigned char D.6265;
  int D.6266;
  _Bool D.6267;
  _Bool D.6268;
  const unsigned char * D.6271;
  unsigned char D.6272;
  int D.6273;
  const unsigned char * D.6274;
  unsigned char D.6275;
  int D.6276;
  _Bool D.6277;
  _Bool D.6278;
  const unsigned char * D.6281;
  unsigned char D.6282;
  int D.6283;
  const unsigned char * D.6284;
  unsigned char D.6285;
  int D.6286;
  gchar * D.6288;
  int D.5204;
  int iftmp.37;
  int D.5203;
  char[3] * D.6294;
  unsigned char D.6295;
  int D.6296;
  unsigned char D.6297;
  int D.6298;
  _Bool D.6299;
  _Bool D.6300;
  _Bool D.6301;
  const unsigned char * D.6304;
  unsigned char D.6305;
  int D.6306;
  const unsigned char * D.6307;
  unsigned char D.6308;
  int D.6309;
  _Bool D.6310;
  _Bool D.6311;
  const unsigned char * D.6314;
  unsigned char D.6315;
  int D.6316;
  const unsigned char * D.6317;
  unsigned char D.6318;
  int D.6319;
  _Bool D.6320;
  _Bool D.6321;
  const unsigned char * D.6324;
  unsigned char D.6325;
  int D.6326;
  const unsigned char * D.6327;
  unsigned char D.6328;
  int D.6329;
  gchar * * D.6331;
  gchar * D.6332;
  int D.5213;
  int iftmp.38;
  int D.5212;
  char[54] * D.6338;
  unsigned char D.6339;
  int D.6340;
  unsigned char D.6341;
  int D.6342;
  _Bool D.6343;
  _Bool D.6344;
  _Bool D.6345;
  const unsigned char * D.6348;
  unsigned char D.6349;
  int D.6350;
  const unsigned char * D.6351;
  unsigned char D.6352;
  int D.6353;
  _Bool D.6354;
  _Bool D.6355;
  const unsigned char * D.6358;
  unsigned char D.6359;
  int D.6360;
  const unsigned char * D.6361;
  unsigned char D.6362;
  int D.6363;
  _Bool D.6364;
  _Bool D.6365;
  const unsigned char * D.6368;
  unsigned char D.6369;
  int D.6370;
  const unsigned char * D.6371;
  unsigned char D.6372;
  int D.6373;
  gchar * * D.6375;
  gchar * D.6376;
  struct GError * error;
  gint argc;
  gchar * * argv;
  gboolean ret;
  char * str;

  try
    {
      str = "\'/usr/bin/gnome-terminal\' -e \"bash -c \'read -p \\\"Press any key to continue...\\\" -n1;\'\"";
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv (str, &argc, &argv, &error);
      if (ret == 0) goto <D.6236>; else goto <D.6237>;
      <D.6236>:
      D.6238 = FAILED ("1. It should return TRUE");
      return D.6238;
      <D.6237>:
      argc.33 = argc;
      if (argc.33 != 3) goto <D.6240>; else goto <D.6241>;
      <D.6240>:
      argc.33 = argc;
      D.6238 = FAILED ("2. argc was %d expected 3", argc.33);
      return D.6238;
      <D.6241>:
      argv.34 = argv;
      if (argv.34 == 0B) goto <D.6243>; else goto <D.6244>;
      <D.6243>:
      D.6238 = FAILED ("3. argv[0] was NULL");
      return D.6238;
      <D.6244>:
      error.35 = error;
      if (error.35 != 0B) goto <D.6246>; else goto <D.6247>;
      <D.6246>:
      D.6238 = FAILED ("4. error was set");
      return D.6238;
      <D.6247>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.34 = argv;
          __s2 = *argv.34;
          D.6251 = "/usr/bin/gnome-terminal";
          D.6252 = MEM[(const unsigned char *)D.6251];
          D.6253 = (int) D.6252;
          D.6254 = *__s2;
          D.6255 = (int) D.6254;
          __result = D.6253 - D.6255;
          {
            D.6256 = __s2_len != 0;
            D.6257 = __result == 0;
            D.6258 = D.6256 & D.6257;
            if (D.6258 != 0) goto <D.6259>; else goto <D.6260>;
            <D.6259>:
            D.6261 = &MEM[(void *)"/usr/bin/gnome-terminal" + 1B];
            D.6262 = *D.6261;
            D.6263 = (int) D.6262;
            D.6264 = __s2 + 1;
            D.6265 = *D.6264;
            D.6266 = (int) D.6265;
            __result = D.6263 - D.6266;
            D.6267 = __s2_len > 1;
            D.6257 = __result == 0;
            D.6268 = D.6267 & D.6257;
            if (D.6268 != 0) goto <D.6269>; else goto <D.6270>;
            <D.6269>:
            D.6271 = &MEM[(void *)"/usr/bin/gnome-terminal" + 2B];
            D.6272 = *D.6271;
            D.6273 = (int) D.6272;
            D.6274 = __s2 + 2;
            D.6275 = *D.6274;
            D.6276 = (int) D.6275;
            __result = D.6273 - D.6276;
            D.6277 = __s2_len > 2;
            D.6257 = __result == 0;
            D.6278 = D.6277 & D.6257;
            if (D.6278 != 0) goto <D.6279>; else goto <D.6280>;
            <D.6279>:
            D.6281 = &MEM[(void *)"/usr/bin/gnome-terminal" + 3B];
            D.6282 = *D.6281;
            D.6283 = (int) D.6282;
            D.6284 = __s2 + 3;
            D.6285 = *D.6284;
            D.6286 = (int) D.6285;
            __result = D.6283 - D.6286;
            <D.6280>:
            <D.6270>:
            <D.6260>:
          }
          D.5194 = __result;
        }
        iftmp.36 = -D.5194;
        goto <D.6287>;
        <D.6250>:
        argv.34 = argv;
        D.6288 = *argv.34;
        iftmp.36 = __builtin_strcmp (D.6288, "/usr/bin/gnome-terminal");
        <D.6287>:
        D.5195 = iftmp.36;
      }
      if (D.5195 != 0) goto <D.6289>; else goto <D.6290>;
      <D.6289>:
      argv.34 = argv;
      D.6288 = *argv.34;
      D.6238 = FAILED ("5. Expected /usr/bin/gnome-terminal got %s", D.6288);
      return D.6238;
      <D.6290>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.34 = argv;
          __s2 = MEM[(gchar * *)argv.34 + 8B];
          D.6294 = "-e";
          D.6295 = MEM[(const unsigned char *)D.6294];
          D.6296 = (int) D.6295;
          D.6297 = *__s2;
          D.6298 = (int) D.6297;
          __result = D.6296 - D.6298;
          {
            D.6299 = __s2_len != 0;
            D.6300 = __result == 0;
            D.6301 = D.6299 & D.6300;
            if (D.6301 != 0) goto <D.6302>; else goto <D.6303>;
            <D.6302>:
            D.6304 = &MEM[(void *)"-e" + 1B];
            D.6305 = *D.6304;
            D.6306 = (int) D.6305;
            D.6307 = __s2 + 1;
            D.6308 = *D.6307;
            D.6309 = (int) D.6308;
            __result = D.6306 - D.6309;
            D.6310 = __s2_len > 1;
            D.6300 = __result == 0;
            D.6311 = D.6310 & D.6300;
            if (D.6311 != 0) goto <D.6312>; else goto <D.6313>;
            <D.6312>:
            D.6314 = &MEM[(void *)"-e" + 2B];
            D.6315 = *D.6314;
            D.6316 = (int) D.6315;
            D.6317 = __s2 + 2;
            D.6318 = *D.6317;
            D.6319 = (int) D.6318;
            __result = D.6316 - D.6319;
            D.6320 = __s2_len > 2;
            D.6300 = __result == 0;
            D.6321 = D.6320 & D.6300;
            if (D.6321 != 0) goto <D.6322>; else goto <D.6323>;
            <D.6322>:
            D.6324 = &MEM[(void *)"-e" + 3B];
            D.6325 = *D.6324;
            D.6326 = (int) D.6325;
            D.6327 = __s2 + 3;
            D.6328 = *D.6327;
            D.6329 = (int) D.6328;
            __result = D.6326 - D.6329;
            <D.6323>:
            <D.6313>:
            <D.6303>:
          }
          D.5203 = __result;
        }
        iftmp.37 = -D.5203;
        goto <D.6330>;
        <D.6293>:
        argv.34 = argv;
        D.6331 = argv.34 + 8;
        D.6332 = *D.6331;
        iftmp.37 = __builtin_strcmp (D.6332, "-e");
        <D.6330>:
        D.5204 = iftmp.37;
      }
      if (D.5204 != 0) goto <D.6333>; else goto <D.6334>;
      <D.6333>:
      argv.34 = argv;
      D.6331 = argv.34 + 8;
      D.6332 = *D.6331;
      D.6238 = FAILED ("6. Expected -e, got: %s", D.6332);
      return D.6238;
      <D.6334>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.34 = argv;
          __s2 = MEM[(gchar * *)argv.34 + 16B];
          D.6338 = "bash -c \'read -p \"Press any key to continue...\" -n1;\'";
          D.6339 = MEM[(const unsigned char *)D.6338];
          D.6340 = (int) D.6339;
          D.6341 = *__s2;
          D.6342 = (int) D.6341;
          __result = D.6340 - D.6342;
          {
            D.6343 = __s2_len != 0;
            D.6344 = __result == 0;
            D.6345 = D.6343 & D.6344;
            if (D.6345 != 0) goto <D.6346>; else goto <D.6347>;
            <D.6346>:
            D.6348 = &MEM[(void *)"bash -c \'read -p \"Press any key to continue...\" -n1;\'" + 1B];
            D.6349 = *D.6348;
            D.6350 = (int) D.6349;
            D.6351 = __s2 + 1;
            D.6352 = *D.6351;
            D.6353 = (int) D.6352;
            __result = D.6350 - D.6353;
            D.6354 = __s2_len > 1;
            D.6344 = __result == 0;
            D.6355 = D.6354 & D.6344;
            if (D.6355 != 0) goto <D.6356>; else goto <D.6357>;
            <D.6356>:
            D.6358 = &MEM[(void *)"bash -c \'read -p \"Press any key to continue...\" -n1;\'" + 2B];
            D.6359 = *D.6358;
            D.6360 = (int) D.6359;
            D.6361 = __s2 + 2;
            D.6362 = *D.6361;
            D.6363 = (int) D.6362;
            __result = D.6360 - D.6363;
            D.6364 = __s2_len > 2;
            D.6344 = __result == 0;
            D.6365 = D.6364 & D.6344;
            if (D.6365 != 0) goto <D.6366>; else goto <D.6367>;
            <D.6366>:
            D.6368 = &MEM[(void *)"bash -c \'read -p \"Press any key to continue...\" -n1;\'" + 3B];
            D.6369 = *D.6368;
            D.6370 = (int) D.6369;
            D.6371 = __s2 + 3;
            D.6372 = *D.6371;
            D.6373 = (int) D.6372;
            __result = D.6370 - D.6373;
            <D.6367>:
            <D.6357>:
            <D.6347>:
          }
          D.5212 = __result;
        }
        iftmp.38 = -D.5212;
        goto <D.6374>;
        <D.6337>:
        argv.34 = argv;
        D.6375 = argv.34 + 16;
        D.6376 = *D.6375;
        iftmp.38 = __builtin_strcmp (D.6376, "bash -c \'read -p \"Press any key to continue...\" -n1;\'");
        <D.6374>:
        D.5213 = iftmp.38;
      }
      if (D.5213 != 0) goto <D.6377>; else goto <D.6378>;
      <D.6377>:
      argv.34 = argv;
      D.6375 = argv.34 + 16;
      D.6376 = *D.6375;
      D.6238 = FAILED ("7. Got unexpected result: %s\n", D.6376);
      return D.6238;
      <D.6378>:
      D.6238 = 0B;
      return D.6238;
    }
  finally
    {
      error = {CLOBBER};
      argc = {CLOBBER};
      argv = {CLOBBER};
    }
}


test_shell_argv5 ()
{
  gchar * D.6383;
  int argc.39;
  gchar * * argv.40;
  struct GError * error.41;
  int D.5229;
  int iftmp.42;
  int D.5228;
  char[5] * D.6396;
  unsigned char D.6397;
  int D.6398;
  unsigned char D.6399;
  int D.6400;
  _Bool D.6401;
  _Bool D.6402;
  _Bool D.6403;
  const unsigned char * D.6406;
  unsigned char D.6407;
  int D.6408;
  const unsigned char * D.6409;
  unsigned char D.6410;
  int D.6411;
  _Bool D.6412;
  _Bool D.6413;
  const unsigned char * D.6416;
  unsigned char D.6417;
  int D.6418;
  const unsigned char * D.6419;
  unsigned char D.6420;
  int D.6421;
  _Bool D.6422;
  _Bool D.6423;
  const unsigned char * D.6426;
  unsigned char D.6427;
  int D.6428;
  const unsigned char * D.6429;
  unsigned char D.6430;
  int D.6431;
  gchar * D.6433;
  int D.5238;
  int iftmp.43;
  int D.5237;
  char[8] * D.6439;
  unsigned char D.6440;
  int D.6441;
  unsigned char D.6442;
  int D.6443;
  _Bool D.6444;
  _Bool D.6445;
  _Bool D.6446;
  const unsigned char * D.6449;
  unsigned char D.6450;
  int D.6451;
  const unsigned char * D.6452;
  unsigned char D.6453;
  int D.6454;
  _Bool D.6455;
  _Bool D.6456;
  const unsigned char * D.6459;
  unsigned char D.6460;
  int D.6461;
  const unsigned char * D.6462;
  unsigned char D.6463;
  int D.6464;
  _Bool D.6465;
  _Bool D.6466;
  const unsigned char * D.6469;
  unsigned char D.6470;
  int D.6471;
  const unsigned char * D.6472;
  unsigned char D.6473;
  int D.6474;
  gchar * * D.6476;
  gchar * D.6477;
  struct GError * error;
  gint argc;
  gchar * * argv;
  gboolean ret;
  char * str;

  try
    {
      str = "echo \"foo\",\"bar\"";
      argv = 0B;
      argc = 0;
      error = 0B;
      ret = monoeg_g_shell_parse_argv (str, &argc, &argv, &error);
      if (ret == 0) goto <D.6381>; else goto <D.6382>;
      <D.6381>:
      D.6383 = FAILED ("1. It should return TRUE");
      return D.6383;
      <D.6382>:
      argc.39 = argc;
      if (argc.39 != 2) goto <D.6385>; else goto <D.6386>;
      <D.6385>:
      argc.39 = argc;
      D.6383 = FAILED ("2. argc was %d expected 2", argc.39);
      return D.6383;
      <D.6386>:
      argv.40 = argv;
      if (argv.40 == 0B) goto <D.6388>; else goto <D.6389>;
      <D.6388>:
      D.6383 = FAILED ("3. argv[0] was NULL");
      return D.6383;
      <D.6389>:
      error.41 = error;
      if (error.41 != 0B) goto <D.6391>; else goto <D.6392>;
      <D.6391>:
      D.6383 = FAILED ("4. error was set");
      return D.6383;
      <D.6392>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.40 = argv;
          __s2 = *argv.40;
          D.6396 = "echo";
          D.6397 = MEM[(const unsigned char *)D.6396];
          D.6398 = (int) D.6397;
          D.6399 = *__s2;
          D.6400 = (int) D.6399;
          __result = D.6398 - D.6400;
          {
            D.6401 = __s2_len != 0;
            D.6402 = __result == 0;
            D.6403 = D.6401 & D.6402;
            if (D.6403 != 0) goto <D.6404>; else goto <D.6405>;
            <D.6404>:
            D.6406 = &MEM[(void *)"echo" + 1B];
            D.6407 = *D.6406;
            D.6408 = (int) D.6407;
            D.6409 = __s2 + 1;
            D.6410 = *D.6409;
            D.6411 = (int) D.6410;
            __result = D.6408 - D.6411;
            D.6412 = __s2_len > 1;
            D.6402 = __result == 0;
            D.6413 = D.6412 & D.6402;
            if (D.6413 != 0) goto <D.6414>; else goto <D.6415>;
            <D.6414>:
            D.6416 = &MEM[(void *)"echo" + 2B];
            D.6417 = *D.6416;
            D.6418 = (int) D.6417;
            D.6419 = __s2 + 2;
            D.6420 = *D.6419;
            D.6421 = (int) D.6420;
            __result = D.6418 - D.6421;
            D.6422 = __s2_len > 2;
            D.6402 = __result == 0;
            D.6423 = D.6422 & D.6402;
            if (D.6423 != 0) goto <D.6424>; else goto <D.6425>;
            <D.6424>:
            D.6426 = &MEM[(void *)"echo" + 3B];
            D.6427 = *D.6426;
            D.6428 = (int) D.6427;
            D.6429 = __s2 + 3;
            D.6430 = *D.6429;
            D.6431 = (int) D.6430;
            __result = D.6428 - D.6431;
            <D.6425>:
            <D.6415>:
            <D.6405>:
          }
          D.5228 = __result;
        }
        iftmp.42 = -D.5228;
        goto <D.6432>;
        <D.6395>:
        argv.40 = argv;
        D.6433 = *argv.40;
        iftmp.42 = __builtin_strcmp (D.6433, "echo");
        <D.6432>:
        D.5229 = iftmp.42;
      }
      if (D.5229 != 0) goto <D.6434>; else goto <D.6435>;
      <D.6434>:
      argv.40 = argv;
      D.6433 = *argv.40;
      D.6383 = FAILED ("5. Expected echo got %s", D.6433);
      return D.6383;
      <D.6435>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          argv.40 = argv;
          __s2 = MEM[(gchar * *)argv.40 + 8B];
          D.6439 = "foo,bar";
          D.6440 = MEM[(const unsigned char *)D.6439];
          D.6441 = (int) D.6440;
          D.6442 = *__s2;
          D.6443 = (int) D.6442;
          __result = D.6441 - D.6443;
          {
            D.6444 = __s2_len != 0;
            D.6445 = __result == 0;
            D.6446 = D.6444 & D.6445;
            if (D.6446 != 0) goto <D.6447>; else goto <D.6448>;
            <D.6447>:
            D.6449 = &MEM[(void *)"foo,bar" + 1B];
            D.6450 = *D.6449;
            D.6451 = (int) D.6450;
            D.6452 = __s2 + 1;
            D.6453 = *D.6452;
            D.6454 = (int) D.6453;
            __result = D.6451 - D.6454;
            D.6455 = __s2_len > 1;
            D.6445 = __result == 0;
            D.6456 = D.6455 & D.6445;
            if (D.6456 != 0) goto <D.6457>; else goto <D.6458>;
            <D.6457>:
            D.6459 = &MEM[(void *)"foo,bar" + 2B];
            D.6460 = *D.6459;
            D.6461 = (int) D.6460;
            D.6462 = __s2 + 2;
            D.6463 = *D.6462;
            D.6464 = (int) D.6463;
            __result = D.6461 - D.6464;
            D.6465 = __s2_len > 2;
            D.6445 = __result == 0;
            D.6466 = D.6465 & D.6445;
            if (D.6466 != 0) goto <D.6467>; else goto <D.6468>;
            <D.6467>:
            D.6469 = &MEM[(void *)"foo,bar" + 3B];
            D.6470 = *D.6469;
            D.6471 = (int) D.6470;
            D.6472 = __s2 + 3;
            D.6473 = *D.6472;
            D.6474 = (int) D.6473;
            __result = D.6471 - D.6474;
            <D.6468>:
            <D.6458>:
            <D.6448>:
          }
          D.5237 = __result;
        }
        iftmp.43 = -D.5237;
        goto <D.6475>;
        <D.6438>:
        argv.40 = argv;
        D.6476 = argv.40 + 8;
        D.6477 = *D.6476;
        iftmp.43 = __builtin_strcmp (D.6477, "foo,bar");
        <D.6475>:
        D.5238 = iftmp.43;
      }
      if (D.5238 != 0) goto <D.6478>; else goto <D.6479>;
      <D.6478>:
      argv.40 = argv;
      D.6476 = argv.40 + 8;
      D.6477 = *D.6476;
      D.6383 = FAILED ("6. Expected foo,bar, got: %s", D.6477);
      return D.6383;
      <D.6479>:
      D.6383 = 0B;
      return D.6383;
    }
  finally
    {
      error = {CLOBBER};
      argc = {CLOBBER};
      argv = {CLOBBER};
    }
}


test_quote ()
{
  int D.5249;
  int iftmp.44;
  int D.5248;
  char[6] * D.6485;
  unsigned char D.6486;
  int D.6487;
  unsigned char D.6488;
  int D.6489;
  _Bool D.6490;
  _Bool D.6491;
  _Bool D.6492;
  const unsigned char * D.6495;
  unsigned char D.6496;
  int D.6497;
  const unsigned char * D.6498;
  unsigned char D.6499;
  int D.6500;
  _Bool D.6501;
  _Bool D.6502;
  const unsigned char * D.6505;
  unsigned char D.6506;
  int D.6507;
  const unsigned char * D.6508;
  unsigned char D.6509;
  int D.6510;
  _Bool D.6511;
  _Bool D.6512;
  const unsigned char * D.6515;
  unsigned char D.6516;
  int D.6517;
  const unsigned char * D.6518;
  unsigned char D.6519;
  int D.6520;
  gchar * D.6522;
  gchar * D.6525;
  int D.5258;
  int iftmp.45;
  int D.5257;
  char[13] * D.6529;
  unsigned char D.6530;
  int D.6531;
  unsigned char D.6532;
  int D.6533;
  _Bool D.6534;
  _Bool D.6535;
  _Bool D.6536;
  const unsigned char * D.6539;
  unsigned char D.6540;
  int D.6541;
  const unsigned char * D.6542;
  unsigned char D.6543;
  int D.6544;
  _Bool D.6545;
  _Bool D.6546;
  const unsigned char * D.6549;
  unsigned char D.6550;
  int D.6551;
  const unsigned char * D.6552;
  unsigned char D.6553;
  int D.6554;
  _Bool D.6555;
  _Bool D.6556;
  const unsigned char * D.6559;
  unsigned char D.6560;
  int D.6561;
  const unsigned char * D.6562;
  unsigned char D.6563;
  int D.6564;
  gchar * D.6566;
  int D.5267;
  int iftmp.46;
  int D.5266;
  char[10] * D.6572;
  unsigned char D.6573;
  int D.6574;
  unsigned char D.6575;
  int D.6576;
  _Bool D.6577;
  _Bool D.6578;
  _Bool D.6579;
  const unsigned char * D.6582;
  unsigned char D.6583;
  int D.6584;
  const unsigned char * D.6585;
  unsigned char D.6586;
  int D.6587;
  _Bool D.6588;
  _Bool D.6589;
  const unsigned char * D.6592;
  unsigned char D.6593;
  int D.6594;
  const unsigned char * D.6595;
  unsigned char D.6596;
  int D.6597;
  _Bool D.6598;
  _Bool D.6599;
  const unsigned char * D.6602;
  unsigned char D.6603;
  int D.6604;
  const unsigned char * D.6605;
  unsigned char D.6606;
  int D.6607;
  gchar * D.6609;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = monoeg_g_shell_quote ("foo");
      D.6485 = "\'foo\'";
      D.6486 = MEM[(const unsigned char *)D.6485];
      D.6487 = (int) D.6486;
      D.6488 = *__s2;
      D.6489 = (int) D.6488;
      __result = D.6487 - D.6489;
      {
        D.6490 = __s2_len != 0;
        D.6491 = __result == 0;
        D.6492 = D.6490 & D.6491;
        if (D.6492 != 0) goto <D.6493>; else goto <D.6494>;
        <D.6493>:
        D.6495 = &MEM[(void *)"\'foo\'" + 1B];
        D.6496 = *D.6495;
        D.6497 = (int) D.6496;
        D.6498 = __s2 + 1;
        D.6499 = *D.6498;
        D.6500 = (int) D.6499;
        __result = D.6497 - D.6500;
        D.6501 = __s2_len > 1;
        D.6491 = __result == 0;
        D.6502 = D.6501 & D.6491;
        if (D.6502 != 0) goto <D.6503>; else goto <D.6504>;
        <D.6503>:
        D.6505 = &MEM[(void *)"\'foo\'" + 2B];
        D.6506 = *D.6505;
        D.6507 = (int) D.6506;
        D.6508 = __s2 + 2;
        D.6509 = *D.6508;
        D.6510 = (int) D.6509;
        __result = D.6507 - D.6510;
        D.6511 = __s2_len > 2;
        D.6491 = __result == 0;
        D.6512 = D.6511 & D.6491;
        if (D.6512 != 0) goto <D.6513>; else goto <D.6514>;
        <D.6513>:
        D.6515 = &MEM[(void *)"\'foo\'" + 3B];
        D.6516 = *D.6515;
        D.6517 = (int) D.6516;
        D.6518 = __s2 + 3;
        D.6519 = *D.6518;
        D.6520 = (int) D.6519;
        __result = D.6517 - D.6520;
        <D.6514>:
        <D.6504>:
        <D.6494>:
      }
      D.5248 = __result;
    }
    iftmp.44 = -D.5248;
    goto <D.6521>;
    <D.6484>:
    D.6522 = monoeg_g_shell_quote ("foo");
    iftmp.44 = __builtin_strcmp (D.6522, "\'foo\'");
    <D.6521>:
    D.5249 = iftmp.44;
  }
  if (D.5249 != 0) goto <D.6523>; else goto <D.6524>;
  <D.6523>:
  D.6525 = FAILED ("Should return \'foo\'");
  return D.6525;
  <D.6524>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = monoeg_g_shell_quote ("foo\'bar");
      D.6529 = "\'foo\'\\\'\'bar\'";
      D.6530 = MEM[(const unsigned char *)D.6529];
      D.6531 = (int) D.6530;
      D.6532 = *__s2;
      D.6533 = (int) D.6532;
      __result = D.6531 - D.6533;
      {
        D.6534 = __s2_len != 0;
        D.6535 = __result == 0;
        D.6536 = D.6534 & D.6535;
        if (D.6536 != 0) goto <D.6537>; else goto <D.6538>;
        <D.6537>:
        D.6539 = &MEM[(void *)"\'foo\'\\\'\'bar\'" + 1B];
        D.6540 = *D.6539;
        D.6541 = (int) D.6540;
        D.6542 = __s2 + 1;
        D.6543 = *D.6542;
        D.6544 = (int) D.6543;
        __result = D.6541 - D.6544;
        D.6545 = __s2_len > 1;
        D.6535 = __result == 0;
        D.6546 = D.6545 & D.6535;
        if (D.6546 != 0) goto <D.6547>; else goto <D.6548>;
        <D.6547>:
        D.6549 = &MEM[(void *)"\'foo\'\\\'\'bar\'" + 2B];
        D.6550 = *D.6549;
        D.6551 = (int) D.6550;
        D.6552 = __s2 + 2;
        D.6553 = *D.6552;
        D.6554 = (int) D.6553;
        __result = D.6551 - D.6554;
        D.6555 = __s2_len > 2;
        D.6535 = __result == 0;
        D.6556 = D.6555 & D.6535;
        if (D.6556 != 0) goto <D.6557>; else goto <D.6558>;
        <D.6557>:
        D.6559 = &MEM[(void *)"\'foo\'\\\'\'bar\'" + 3B];
        D.6560 = *D.6559;
        D.6561 = (int) D.6560;
        D.6562 = __s2 + 3;
        D.6563 = *D.6562;
        D.6564 = (int) D.6563;
        __result = D.6561 - D.6564;
        <D.6558>:
        <D.6548>:
        <D.6538>:
      }
      D.5257 = __result;
    }
    iftmp.45 = -D.5257;
    goto <D.6565>;
    <D.6528>:
    D.6566 = monoeg_g_shell_quote ("foo\'bar");
    iftmp.45 = __builtin_strcmp (D.6566, "\'foo\'\\\'\'bar\'");
    <D.6565>:
    D.5258 = iftmp.45;
  }
  if (D.5258 != 0) goto <D.6567>; else goto <D.6568>;
  <D.6567>:
  D.6525 = FAILED ("Should return \'foo\'\\\'\'bar\'");
  return D.6525;
  <D.6568>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = monoeg_g_shell_quote ("foo bar");
      D.6572 = "\'foo bar\'";
      D.6573 = MEM[(const unsigned char *)D.6572];
      D.6574 = (int) D.6573;
      D.6575 = *__s2;
      D.6576 = (int) D.6575;
      __result = D.6574 - D.6576;
      {
        D.6577 = __s2_len != 0;
        D.6578 = __result == 0;
        D.6579 = D.6577 & D.6578;
        if (D.6579 != 0) goto <D.6580>; else goto <D.6581>;
        <D.6580>:
        D.6582 = &MEM[(void *)"\'foo bar\'" + 1B];
        D.6583 = *D.6582;
        D.6584 = (int) D.6583;
        D.6585 = __s2 + 1;
        D.6586 = *D.6585;
        D.6587 = (int) D.6586;
        __result = D.6584 - D.6587;
        D.6588 = __s2_len > 1;
        D.6578 = __result == 0;
        D.6589 = D.6588 & D.6578;
        if (D.6589 != 0) goto <D.6590>; else goto <D.6591>;
        <D.6590>:
        D.6592 = &MEM[(void *)"\'foo bar\'" + 2B];
        D.6593 = *D.6592;
        D.6594 = (int) D.6593;
        D.6595 = __s2 + 2;
        D.6596 = *D.6595;
        D.6597 = (int) D.6596;
        __result = D.6594 - D.6597;
        D.6598 = __s2_len > 2;
        D.6578 = __result == 0;
        D.6599 = D.6598 & D.6578;
        if (D.6599 != 0) goto <D.6600>; else goto <D.6601>;
        <D.6600>:
        D.6602 = &MEM[(void *)"\'foo bar\'" + 3B];
        D.6603 = *D.6602;
        D.6604 = (int) D.6603;
        D.6605 = __s2 + 3;
        D.6606 = *D.6605;
        D.6607 = (int) D.6606;
        __result = D.6604 - D.6607;
        <D.6601>:
        <D.6591>:
        <D.6581>:
      }
      D.5266 = __result;
    }
    iftmp.46 = -D.5266;
    goto <D.6608>;
    <D.6571>:
    D.6609 = monoeg_g_shell_quote ("foo bar");
    iftmp.46 = __builtin_strcmp (D.6609, "\'foo bar\'");
    <D.6608>:
    D.5267 = iftmp.46;
  }
  if (D.5267 != 0) goto <D.6610>; else goto <D.6611>;
  <D.6610>:
  D.6525 = FAILED ("Should return \'foo bar\'");
  return D.6525;
  <D.6611>:
  D.6525 = 0B;
  return D.6525;
}


shell_tests_init ()
{
  struct Test * D.6613;

  D.6613 = &shell_tests;
  return D.6613;
}