monoeg_g_spawn_command_line_sync (const gchar * command_line, gchar * * standard_output, gchar * * standard_error, gint * exit_status, struct GError * * error)
{
  int D.6302;
  gboolean D.6305;
  int D.6308;
  int D.6313;
  int D.6318;
  int D.6319;
  int D.6326;
  int D.6327;
  int D.6328;
  gchar * * argv.0;
  gchar * D.6330;
  int D.6331;
  _Bool D.6340;
  _Bool D.6341;
  _Bool D.6342;
  int * D.6348;
  int D.6349;
  union 
{
  int __in;
  int __i;
} D.6257;
  int status.1;
  int D.6351;
  int D.6352;
  union 
{
  int __in;
  int __i;
} D.6261;
  int D.6357;
  int D.6358;
  int D.6359;
  pid_t pid;
  gchar * * argv;
  gint argc;
  int stdout_pipe[2];
  int stderr_pipe[2];
  int status;
  int res;
  typedef union 
{
  int __in;
  int __i;
} unionunion 
{
  int __in;
  int __i;
};

  try
    {
      stdout_pipe[0] = -1;
      stdout_pipe[1] = -1;
      stderr_pipe[0] = -1;
      stderr_pipe[1] = -1;
      D.6302 = monoeg_g_shell_parse_argv (command_line, &argc, &argv, error);
      if (D.6302 == 0) goto <D.6303>; else goto <D.6304>;
      <D.6303>:
      D.6305 = 0;
      return D.6305;
      <D.6304>:
      if (standard_output != 0B) goto <D.6306>; else goto <D.6307>;
      <D.6306>:
      D.6308 = create_pipe (&stdout_pipe, error);
      if (D.6308 == 0) goto <D.6309>; else goto <D.6310>;
      <D.6309>:
      D.6305 = 0;
      return D.6305;
      <D.6310>:
      <D.6307>:
      if (standard_error != 0B) goto <D.6311>; else goto <D.6312>;
      <D.6311>:
      D.6313 = create_pipe (&stderr_pipe, error);
      if (D.6313 == 0) goto <D.6314>; else goto <D.6315>;
      <D.6314>:
      if (standard_output != 0B) goto <D.6316>; else goto <D.6317>;
      <D.6316>:
      D.6318 = stdout_pipe[0];
      close (D.6318);
      D.6319 = stdout_pipe[1];
      close (D.6319);
      <D.6317>:
      D.6305 = 0;
      return D.6305;
      <D.6315>:
      <D.6312>:
      pid = fork ();
      if (pid == 0) goto <D.6320>; else goto <D.6321>;
      <D.6320>:
      {
        gint i;

        if (standard_output != 0B) goto <D.6322>; else goto <D.6323>;
        <D.6322>:
        D.6318 = stdout_pipe[0];
        close (D.6318);
        D.6319 = stdout_pipe[1];
        dup2 (D.6319, 1);
        <D.6323>:
        if (standard_error != 0B) goto <D.6324>; else goto <D.6325>;
        <D.6324>:
        D.6326 = stderr_pipe[0];
        close (D.6326);
        D.6327 = stderr_pipe[1];
        dup2 (D.6327, 2);
        <D.6325>:
        D.6328 = getdtablesize ();
        i = D.6328 + -1;
        goto <D.6249>;
        <D.6248>:
        close (i);
        i = i + -1;
        <D.6249>:
        if (i > 2) goto <D.6248>; else goto <D.6250>;
        <D.6250>:
        argv.0 = argv;
        D.6330 = *argv.0;
        D.6331 = monoeg_g_path_is_absolute (D.6330);
        if (D.6331 == 0) goto <D.6332>; else goto <D.6333>;
        <D.6332>:
        {
          gchar * arg0;

          argv.0 = argv;
          D.6330 = *argv.0;
          arg0 = monoeg_g_find_program_in_path (D.6330);
          if (arg0 == 0B) goto <D.6334>; else goto <D.6335>;
          <D.6334>:
          exit (1);
          <D.6335>:
          argv.0 = argv;
          *argv.0 = arg0;
        }
        <D.6333>:
        argv.0 = argv;
        argv.0 = argv;
        D.6330 = *argv.0;
        execv (D.6330, argv.0);
        exit (1);
      }
      <D.6321>:
      argv.0 = argv;
      monoeg_g_strfreev (argv.0);
      if (standard_output != 0B) goto <D.6336>; else goto <D.6337>;
      <D.6336>:
      D.6319 = stdout_pipe[1];
      close (D.6319);
      <D.6337>:
      if (standard_error != 0B) goto <D.6338>; else goto <D.6339>;
      <D.6338>:
      D.6327 = stderr_pipe[1];
      close (D.6327);
      <D.6339>:
      D.6340 = standard_output != 0B;
      D.6341 = standard_error != 0B;
      D.6342 = D.6340 | D.6341;
      if (D.6342 != 0) goto <D.6343>; else goto <D.6344>;
      <D.6343>:
      D.6326 = stderr_pipe[0];
      D.6318 = stdout_pipe[0];
      res = read_pipes (D.6318, standard_output, D.6326, standard_error, error);
      if (res != 0) goto <D.6345>; else goto <D.6346>;
      <D.6345>:
      waitpid (pid, &status, 1);
      D.6305 = 0;
      return D.6305;
      <D.6346>:
      <D.6344>:
      <D.6252>:
      res = waitpid (pid, &status, 0);
      if (res == -1) goto <D.6347>; else goto <D.6253>;
      <D.6347>:
      D.6348 = __errno_location ();
      D.6349 = *D.6348;
      if (D.6349 == 4) goto <D.6252>; else goto <D.6253>;
      <D.6253>:
      status.1 = status;
      D.6257.__in = status.1;
      D.6351 = D.6257.__i;
      D.6352 = D.6351 & 127;
      if (D.6352 == 0) goto <D.6353>; else goto <D.6354>;
      <D.6353>:
      if (exit_status != 0B) goto <D.6355>; else goto <D.6356>;
      <D.6355>:
      {
        typedef union 
      {
        int __in;
        int __i;
      } unionunion 
      {
        int __in;
        int __i;
      };

        status.1 = status;
        D.6261.__in = status.1;
        D.6357 = D.6261.__i;
        D.6358 = D.6357 & 65280;
        D.6359 = D.6358 >> 8;
        *exit_status = D.6359;
      }
      <D.6356>:
      <D.6354>:
      D.6305 = 1;
      return D.6305;
    }
  finally
    {
      argv = {CLOBBER};
      argc = {CLOBBER};
      stdout_pipe = {CLOBBER};
      stderr_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


create_pipe (int * fds, struct GError * * error)
{
  int D.6362;
  struct GError * D.6367;
  gboolean D.6368;

  D.6362 = pipe (fds);
  if (D.6362 == -1) goto <D.6363>; else goto <D.6364>;
  <D.6363>:
  if (error != 0B) goto <D.6365>; else goto <D.6366>;
  <D.6365>:
  D.6367 = monoeg_g_error_new (0B, 1, "%s", "Error creating pipe.");
  *error = D.6367;
  <D.6366>:
  D.6368 = 0;
  return D.6368;
  <D.6364>:
  D.6368 = 1;
  return D.6368;
}


read_pipes (int outfd, gchar * * out_str, int errfd, gchar * * err_str, struct GError * * error)
{
  _Bool D.6370;
  _Bool D.6371;
  _Bool D.6376;
  _Bool D.6377;
  _Bool D.6378;
  _Bool D.6380;
  _Bool D.6381;
  _Bool D.6382;
  long int D.6209;
  long int iftmp.2;
  int D.6386;
  long int iftmp.3;
  unsigned int __d.4;
  long int D.6395;
  long int D.6396;
  int D.6397;
  long int D.6398;
  long int D.6399;
  _Bool D.6400;
  _Bool D.6401;
  _Bool D.6402;
  long int D.6211;
  long int iftmp.5;
  int D.6406;
  long int iftmp.6;
  unsigned int __d.7;
  long int D.6415;
  long int D.6416;
  int D.6417;
  long int D.6418;
  long int D.6419;
  int D.6420;
  int D.6421;
  long int D.6213;
  long int iftmp.8;
  int D.6429;
  long int iftmp.9;
  unsigned int __d.10;
  long int D.6438;
  long int D.6439;
  long int D.6440;
  int D.6445;
  long int D.6215;
  long int iftmp.11;
  int D.6451;
  long int iftmp.12;
  unsigned int __d.13;
  long int D.6460;
  long int D.6461;
  long int D.6462;
  int * D.6471;
  int D.6472;
  gchar * D.6475;
  gchar * D.6478;
  struct fd_set rfds;
  int res;
  gboolean out_closed;
  gboolean err_closed;
  struct GString * out;
  struct GString * err;
  gchar * buffer;
  gint nread;

  try
    {
      out = 0B;
      err = 0B;
      buffer = 0B;
      D.6370 = outfd < 0;
      out_closed = (gboolean) D.6370;
      D.6371 = errfd < 0;
      err_closed = (gboolean) D.6371;
      if (out_str != 0B) goto <D.6372>; else goto <D.6373>;
      <D.6372>:
      *out_str = 0B;
      out = monoeg_g_string_new ("");
      <D.6373>:
      if (err_str != 0B) goto <D.6374>; else goto <D.6375>;
      <D.6374>:
      *err_str = 0B;
      err = monoeg_g_string_new ("");
      <D.6375>:
      <D.6216>:
      D.6376 = out_closed != 0;
      D.6377 = err_closed != 0;
      D.6378 = D.6376 & D.6377;
      if (D.6378 != 0) goto <D.6205>; else goto <D.6379>;
      <D.6379>:
      {
        int __d0;
        int __d1;

        __asm__ __volatile__("cld; rep; stosl" : "=c" __d0, "=D" __d1 : "a" 0, "0" 32, "1" &rfds.fds_bits[0] : "memory");
      }
      D.6380 = out_closed == 0;
      D.6381 = outfd >= 0;
      D.6382 = D.6380 & D.6381;
      if (D.6382 != 0) goto <D.6383>; else goto <D.6384>;
      <D.6383>:
      {
        long int __d;

        __d = outfd;
        D.6386 = __builtin_constant_p (__d);
        if (D.6386 != 0) goto <D.6387>; else goto <D.6388>;
        <D.6387>:
        __d.4 = (unsigned int) __d;
        if (__d.4 <= 1023) goto <D.6391>; else goto <D.6392>;
        <D.6391>:
        iftmp.3 = __d / 32;
        goto <D.6393>;
        <D.6392>:
        iftmp.3 = __fdelt_warn (__d);
        <D.6393>:
        iftmp.2 = iftmp.3;
        goto <D.6394>;
        <D.6388>:
        iftmp.2 = __fdelt_chk (__d);
        <D.6394>:
        D.6209 = iftmp.2;
      }
      D.6395 = D.6209;
      D.6396 = rfds.fds_bits[D.6395];
      D.6397 = outfd % 32;
      D.6398 = 1 << D.6397;
      D.6399 = D.6396 | D.6398;
      rfds.fds_bits[D.6395] = D.6399;
      <D.6384>:
      D.6400 = err_closed == 0;
      D.6401 = errfd >= 0;
      D.6402 = D.6400 & D.6401;
      if (D.6402 != 0) goto <D.6403>; else goto <D.6404>;
      <D.6403>:
      {
        long int __d;

        __d = errfd;
        D.6406 = __builtin_constant_p (__d);
        if (D.6406 != 0) goto <D.6407>; else goto <D.6408>;
        <D.6407>:
        __d.7 = (unsigned int) __d;
        if (__d.7 <= 1023) goto <D.6411>; else goto <D.6412>;
        <D.6411>:
        iftmp.6 = __d / 32;
        goto <D.6413>;
        <D.6412>:
        iftmp.6 = __fdelt_warn (__d);
        <D.6413>:
        iftmp.5 = iftmp.6;
        goto <D.6414>;
        <D.6408>:
        iftmp.5 = __fdelt_chk (__d);
        <D.6414>:
        D.6211 = iftmp.5;
      }
      D.6415 = D.6211;
      D.6416 = rfds.fds_bits[D.6415];
      D.6417 = errfd % 32;
      D.6418 = 1 << D.6417;
      D.6419 = D.6416 | D.6418;
      rfds.fds_bits[D.6415] = D.6419;
      <D.6404>:
      D.6420 = MAX_EXPR <errfd, outfd>;
      D.6421 = D.6420 + 1;
      res = select (D.6421, &rfds, 0B, 0B, 0B);
      if (res > 0) goto <D.6422>; else goto <D.6423>;
      <D.6422>:
      if (buffer == 0B) goto <D.6424>; else goto <D.6425>;
      <D.6424>:
      buffer = monoeg_malloc (1024);
      <D.6425>:
      if (out_closed == 0) goto <D.6426>; else goto <D.6427>;
      <D.6426>:
      {
        long int __d;

        __d = outfd;
        D.6429 = __builtin_constant_p (__d);
        if (D.6429 != 0) goto <D.6430>; else goto <D.6431>;
        <D.6430>:
        __d.10 = (unsigned int) __d;
        if (__d.10 <= 1023) goto <D.6434>; else goto <D.6435>;
        <D.6434>:
        iftmp.9 = __d / 32;
        goto <D.6436>;
        <D.6435>:
        iftmp.9 = __fdelt_warn (__d);
        <D.6436>:
        iftmp.8 = iftmp.9;
        goto <D.6437>;
        <D.6431>:
        iftmp.8 = __fdelt_chk (__d);
        <D.6437>:
        D.6213 = iftmp.8;
      }
      D.6438 = rfds.fds_bits[D.6213];
      D.6397 = outfd % 32;
      D.6439 = D.6438 >> D.6397;
      D.6440 = D.6439 & 1;
      if (D.6440 != 0) goto <D.6441>; else goto <D.6442>;
      <D.6441>:
      nread = safe_read (outfd, buffer, 1024, error);
      if (nread < 0) goto <D.6443>; else goto <D.6444>;
      <D.6443>:
      close (errfd);
      close (outfd);
      D.6445 = -1;
      return D.6445;
      <D.6444>:
      monoeg_g_string_append_len (out, buffer, nread);
      if (nread <= 0) goto <D.6446>; else goto <D.6447>;
      <D.6446>:
      out_closed = 1;
      close (outfd);
      <D.6447>:
      <D.6442>:
      <D.6427>:
      if (err_closed == 0) goto <D.6448>; else goto <D.6449>;
      <D.6448>:
      {
        long int __d;

        __d = errfd;
        D.6451 = __builtin_constant_p (__d);
        if (D.6451 != 0) goto <D.6452>; else goto <D.6453>;
        <D.6452>:
        __d.13 = (unsigned int) __d;
        if (__d.13 <= 1023) goto <D.6456>; else goto <D.6457>;
        <D.6456>:
        iftmp.12 = __d / 32;
        goto <D.6458>;
        <D.6457>:
        iftmp.12 = __fdelt_warn (__d);
        <D.6458>:
        iftmp.11 = iftmp.12;
        goto <D.6459>;
        <D.6453>:
        iftmp.11 = __fdelt_chk (__d);
        <D.6459>:
        D.6215 = iftmp.11;
      }
      D.6460 = rfds.fds_bits[D.6215];
      D.6417 = errfd % 32;
      D.6461 = D.6460 >> D.6417;
      D.6462 = D.6461 & 1;
      if (D.6462 != 0) goto <D.6463>; else goto <D.6464>;
      <D.6463>:
      nread = safe_read (errfd, buffer, 1024, error);
      if (nread < 0) goto <D.6465>; else goto <D.6466>;
      <D.6465>:
      close (errfd);
      close (outfd);
      D.6445 = -1;
      return D.6445;
      <D.6466>:
      monoeg_g_string_append_len (err, buffer, nread);
      if (nread <= 0) goto <D.6467>; else goto <D.6468>;
      <D.6467>:
      err_closed = 1;
      close (errfd);
      <D.6468>:
      <D.6464>:
      <D.6449>:
      <D.6423>:
      if (res > 0) goto <D.6216>; else goto <D.6469>;
      <D.6469>:
      if (res == -1) goto <D.6470>; else goto <D.6205>;
      <D.6470>:
      D.6471 = __errno_location ();
      D.6472 = *D.6471;
      if (D.6472 == 4) goto <D.6216>; else goto <D.6205>;
      <D.6205>:
      monoeg_g_free (buffer);
      if (out_str != 0B) goto <D.6473>; else goto <D.6474>;
      <D.6473>:
      D.6475 = monoeg_g_string_free (out, 0);
      *out_str = D.6475;
      <D.6474>:
      if (err_str != 0B) goto <D.6476>; else goto <D.6477>;
      <D.6476>:
      D.6478 = monoeg_g_string_free (err, 0);
      *err_str = D.6478;
      <D.6477>:
      D.6445 = 0;
      return D.6445;
    }
  finally
    {
      rfds = {CLOBBER};
    }
}


safe_read (int fd, gchar * buffer, gint count, struct GError * * error)
{
  unsigned int count.14;
  int * D.6483;
  int D.6484;
  _Bool D.6485;
  _Bool D.6486;
  _Bool D.6487;
  struct GError * D.6490;
  int D.6491;
  int res;

  <D.6188>:
  count.14 = (unsigned int) count;
  res = read (fd, buffer, count.14);
  if (res == -1) goto <D.6482>; else goto <D.6189>;
  <D.6482>:
  D.6483 = __errno_location ();
  D.6484 = *D.6483;
  if (D.6484 == 4) goto <D.6188>; else goto <D.6189>;
  <D.6189>:
  D.6485 = res == -1;
  D.6486 = error != 0B;
  D.6487 = D.6485 & D.6486;
  if (D.6487 != 0) goto <D.6488>; else goto <D.6489>;
  <D.6488>:
  D.6490 = monoeg_g_error_new (0B, 1, "%s", "Error reading from pipe.");
  *error = D.6490;
  <D.6489>:
  D.6491 = res;
  return D.6491;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.6493;
  int D.6496;
  ssize_t D.6499;
  unsigned int D.6500;
  unsigned int D.6501;
  unsigned int D.6504;

  D.6493 = __builtin_object_size (__buf, 0);
  if (D.6493 != 4294967295) goto <D.6494>; else goto <D.6495>;
  <D.6494>:
  D.6496 = __builtin_constant_p (__nbytes);
  if (D.6496 == 0) goto <D.6497>; else goto <D.6498>;
  <D.6497>:
  D.6500 = __builtin_object_size (__buf, 0);
  D.6499 = __read_chk (__fd, __buf, __nbytes, D.6500);
  return D.6499;
  <D.6498>:
  D.6501 = __builtin_object_size (__buf, 0);
  if (D.6501 < __nbytes) goto <D.6502>; else goto <D.6503>;
  <D.6502>:
  D.6504 = __builtin_object_size (__buf, 0);
  D.6499 = __read_chk_warn (__fd, __buf, __nbytes, D.6504);
  return D.6499;
  <D.6503>:
  <D.6495>:
  D.6499 = __read_alias (__fd, __buf, __nbytes);
  return D.6499;
}


monoeg_g_spawn_async_with_pipes (const gchar * working_directory, gchar * * argv, gchar * * envp, GSpawnFlags flags, void (*GSpawnChildSetupFunc) (void *) child_setup, void * user_data, GPid * child_pid, gint * standard_input, gint * standard_output, gint * standard_error, struct GError * * error)
{
  gboolean D.6508;
  int D.6509;
  int D.6514;
  int D.6517;
  int D.6518;
  int D.6521;
  int D.6524;
  int D.6525;
  int D.6528;
  int D.6531;
  int D.6532;
  int pid.15;
  int pid.16;
  int D.6537;
  int D.6538;
  struct GError * D.6541;
  unsigned int D.6544;
  int pid.17;
  _Bool D.6550;
  int D.6551;
  int pid.18;
  int * D.6556;
  int err.19;
  int D.6560;
  unsigned int D.6567;
  unsigned int D.6573;
  unsigned int D.6579;
  unsigned int D.6582;
  int D.6585;
  gchar * * iftmp.20;
  unsigned int D.6587;
  int D.6597;
  unsigned int D.6599;
  gchar * D.6600;
  int status.21;
  struct GError * D.6612;
  int D.6618;
  char * D.6623;
  struct GError * D.6624;
  pid_t pid;
  int info_pipe[2];
  int in_pipe[2];
  int out_pipe[2];
  int err_pipe[2];
  int status;

  try
    {
      in_pipe[0] = -1;
      in_pipe[1] = -1;
      out_pipe[0] = -1;
      out_pipe[1] = -1;
      err_pipe[0] = -1;
      err_pipe[1] = -1;
      if (argv == 0B) goto <D.6506>; else goto <D.6507>;
      <D.6506>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gspawn.c", 324, "argv != NULL");
      D.6508 = 0;
      return D.6508;
      <D.6507>:
      D.6509 = create_pipe (&info_pipe, error);
      if (D.6509 == 0) goto <D.6510>; else goto <D.6511>;
      <D.6510>:
      D.6508 = 0;
      return D.6508;
      <D.6511>:
      if (standard_output != 0B) goto <D.6512>; else goto <D.6513>;
      <D.6512>:
      D.6514 = create_pipe (&out_pipe, error);
      if (D.6514 == 0) goto <D.6515>; else goto <D.6516>;
      <D.6515>:
      D.6517 = info_pipe[0];
      close (D.6517);
      D.6518 = info_pipe[1];
      close (D.6518);
      D.6508 = 0;
      return D.6508;
      <D.6516>:
      <D.6513>:
      if (standard_error != 0B) goto <D.6519>; else goto <D.6520>;
      <D.6519>:
      D.6521 = create_pipe (&err_pipe, error);
      if (D.6521 == 0) goto <D.6522>; else goto <D.6523>;
      <D.6522>:
      D.6517 = info_pipe[0];
      close (D.6517);
      D.6518 = info_pipe[1];
      close (D.6518);
      D.6524 = out_pipe[0];
      close (D.6524);
      D.6525 = out_pipe[1];
      close (D.6525);
      D.6508 = 0;
      return D.6508;
      <D.6523>:
      <D.6520>:
      if (standard_input != 0B) goto <D.6526>; else goto <D.6527>;
      <D.6526>:
      D.6528 = create_pipe (&in_pipe, error);
      if (D.6528 == 0) goto <D.6529>; else goto <D.6530>;
      <D.6529>:
      D.6517 = info_pipe[0];
      close (D.6517);
      D.6518 = info_pipe[1];
      close (D.6518);
      D.6524 = out_pipe[0];
      close (D.6524);
      D.6525 = out_pipe[1];
      close (D.6525);
      D.6531 = err_pipe[0];
      close (D.6531);
      D.6532 = err_pipe[1];
      close (D.6532);
      D.6508 = 0;
      return D.6508;
      <D.6530>:
      <D.6527>:
      pid.15 = fork ();
      pid = pid.15;
      pid.16 = pid;
      if (pid.16 == -1) goto <D.6535>; else goto <D.6536>;
      <D.6535>:
      D.6517 = info_pipe[0];
      close (D.6517);
      D.6518 = info_pipe[1];
      close (D.6518);
      D.6524 = out_pipe[0];
      close (D.6524);
      D.6525 = out_pipe[1];
      close (D.6525);
      D.6531 = err_pipe[0];
      close (D.6531);
      D.6532 = err_pipe[1];
      close (D.6532);
      D.6537 = in_pipe[0];
      close (D.6537);
      D.6538 = in_pipe[1];
      close (D.6538);
      if (error != 0B) goto <D.6539>; else goto <D.6540>;
      <D.6539>:
      D.6541 = monoeg_g_error_new (0B, 1, "%s", "Error in fork ()");
      *error = D.6541;
      <D.6540>:
      D.6508 = 0;
      return D.6508;
      <D.6536>:
      pid.16 = pid;
      if (pid.16 == 0) goto <D.6542>; else goto <D.6543>;
      <D.6542>:
      D.6544 = flags & 2;
      if (D.6544 == 0) goto <D.6545>; else goto <D.6546>;
      <D.6545>:
      pid.17 = fork ();
      pid = pid.17;
      <D.6546>:
      pid.16 = pid;
      if (pid.16 != 0) goto <D.6548>; else goto <D.6549>;
      <D.6548>:
      pid.16 = pid;
      D.6550 = pid.16 == -1;
      D.6551 = (int) D.6550;
      exit (D.6551);
      <D.6549>:
      {
        gint i;
        int fd;
        gchar * arg0;
        gchar * * actual_args;
        gint unused;

        D.6517 = info_pipe[0];
        close (D.6517);
        D.6538 = in_pipe[1];
        close (D.6538);
        D.6524 = out_pipe[0];
        close (D.6524);
        D.6531 = err_pipe[0];
        close (D.6531);
        D.6518 = info_pipe[1];
        fcntl (D.6518, 2, 1);
        D.6544 = flags & 2;
        if (D.6544 == 0) goto <D.6552>; else goto <D.6553>;
        <D.6552>:
        pid.18 = getpid ();
        pid = pid.18;
        <D.6286>:
        D.6518 = info_pipe[1];
        unused = write_all (D.6518, &pid, 4);
        if (unused == -1) goto <D.6555>; else goto <D.6287>;
        <D.6555>:
        D.6556 = __errno_location ();
        err.19 = *D.6556;
        if (err.19 == 4) goto <D.6286>; else goto <D.6287>;
        <D.6287>:
        <D.6553>:
        if (working_directory != 0B) goto <D.6558>; else goto <D.6559>;
        <D.6558>:
        D.6560 = chdir (working_directory);
        if (D.6560 == -1) goto <D.6561>; else goto <D.6562>;
        <D.6561>:
        {
          int err;

          try
            {
              D.6556 = __errno_location ();
              err.19 = *D.6556;
              err = err.19;
              <D.6289>:
              D.6518 = info_pipe[1];
              unused = write_all (D.6518, &err, 4);
              if (unused == -1) goto <D.6563>; else goto <D.6290>;
              <D.6563>:
              D.6556 = __errno_location ();
              err.19 = *D.6556;
              if (err.19 == 4) goto <D.6289>; else goto <D.6290>;
              <D.6290>:
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6562>:
        <D.6559>:
        if (standard_output != 0B) goto <D.6564>; else goto <D.6565>;
        <D.6564>:
        D.6525 = out_pipe[1];
        dup2 (D.6525, 1);
        goto <D.6566>;
        <D.6565>:
        D.6567 = flags & 8;
        if (D.6567 != 0) goto <D.6568>; else goto <D.6569>;
        <D.6568>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 1);
        <D.6569>:
        <D.6566>:
        if (standard_error != 0B) goto <D.6570>; else goto <D.6571>;
        <D.6570>:
        D.6532 = err_pipe[1];
        dup2 (D.6532, 2);
        goto <D.6572>;
        <D.6571>:
        D.6573 = flags & 16;
        if (D.6573 != 0) goto <D.6574>; else goto <D.6575>;
        <D.6574>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 2);
        <D.6575>:
        <D.6572>:
        if (standard_input != 0B) goto <D.6576>; else goto <D.6577>;
        <D.6576>:
        D.6537 = in_pipe[0];
        dup2 (D.6537, 0);
        goto <D.6578>;
        <D.6577>:
        D.6579 = flags & 32;
        if (D.6579 == 0) goto <D.6580>; else goto <D.6581>;
        <D.6580>:
        fd = open ("/dev/null", 0);
        dup2 (fd, 0);
        <D.6581>:
        <D.6578>:
        D.6582 = flags & 1;
        if (D.6582 != 0) goto <D.6583>; else goto <D.6584>;
        <D.6583>:
        D.6585 = getdtablesize ();
        i = D.6585 + -1;
        goto <D.6292>;
        <D.6291>:
        close (i);
        i = i + -1;
        <D.6292>:
        if (i > 2) goto <D.6291>; else goto <D.6293>;
        <D.6293>:
        <D.6584>:
        D.6587 = flags & 64;
        if (D.6587 != 0) goto <D.6588>; else goto <D.6589>;
        <D.6588>:
        iftmp.20 = argv + 4;
        goto <D.6590>;
        <D.6589>:
        iftmp.20 = argv;
        <D.6590>:
        actual_args = iftmp.20;
        if (envp == 0B) goto <D.6591>; else goto <D.6592>;
        <D.6591>:
        envp = environ;
        <D.6592>:
        if (child_setup != 0B) goto <D.6593>; else goto <D.6594>;
        <D.6593>:
        child_setup (user_data);
        <D.6594>:
        arg0 = *argv;
        D.6597 = monoeg_g_path_is_absolute (arg0);
        if (D.6597 == 0) goto <D.6595>; else goto <D.6598>;
        <D.6598>:
        D.6599 = flags & 4;
        if (D.6599 != 0) goto <D.6595>; else goto <D.6596>;
        <D.6595>:
        D.6600 = *argv;
        arg0 = monoeg_g_find_program_in_path (D.6600);
        if (arg0 == 0B) goto <D.6601>; else goto <D.6602>;
        <D.6601>:
        {
          int err;

          try
            {
              err = 2;
              D.6518 = info_pipe[1];
              write_all (D.6518, &err, 4);
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6602>:
        <D.6596>:
        execve (arg0, actual_args, envp);
        D.6556 = __errno_location ();
        D.6518 = info_pipe[1];
        write_all (D.6518, D.6556, 4);
        exit (0);
      }
      <D.6543>:
      D.6544 = flags & 2;
      if (D.6544 == 0) goto <D.6603>; else goto <D.6604>;
      <D.6603>:
      {
        int w;

        <D.6296>:
        pid.16 = pid;
        w = waitpid (pid.16, &status, 0);
        if (w == -1) goto <D.6605>; else goto <D.6297>;
        <D.6605>:
        D.6556 = __errno_location ();
        err.19 = *D.6556;
        if (err.19 == 4) goto <D.6296>; else goto <D.6297>;
        <D.6297>:
        status.21 = status;
        if (status.21 == 1) goto <D.6606>; else goto <D.6609>;
        <D.6609>:
        if (w == -1) goto <D.6606>; else goto <D.6607>;
        <D.6606>:
        D.6517 = info_pipe[0];
        close (D.6517);
        D.6518 = info_pipe[1];
        close (D.6518);
        D.6524 = out_pipe[0];
        close (D.6524);
        D.6525 = out_pipe[1];
        close (D.6525);
        D.6531 = err_pipe[0];
        close (D.6531);
        D.6532 = err_pipe[1];
        close (D.6532);
        D.6537 = in_pipe[0];
        close (D.6537);
        D.6538 = in_pipe[1];
        close (D.6538);
        if (error != 0B) goto <D.6610>; else goto <D.6611>;
        <D.6610>:
        status.21 = status;
        D.6612 = monoeg_g_error_new (0B, 1, "Error in fork (): %d", status.21);
        *error = D.6612;
        <D.6611>:
        D.6508 = 0;
        return D.6508;
        <D.6607>:
      }
      <D.6604>:
      D.6518 = info_pipe[1];
      close (D.6518);
      D.6537 = in_pipe[0];
      close (D.6537);
      D.6525 = out_pipe[1];
      close (D.6525);
      D.6532 = err_pipe[1];
      close (D.6532);
      D.6544 = flags & 2;
      if (D.6544 == 0) goto <D.6613>; else goto <D.6614>;
      <D.6613>:
      {
        int x;

        <D.6299>:
        D.6517 = info_pipe[0];
        x = read (D.6517, &pid, 4);
        if (x == -1) goto <D.6615>; else goto <D.6300>;
        <D.6615>:
        D.6556 = __errno_location ();
        err.19 = *D.6556;
        if (err.19 == 4) goto <D.6299>; else goto <D.6300>;
        <D.6300>:
      }
      <D.6614>:
      if (child_pid != 0B) goto <D.6616>; else goto <D.6617>;
      <D.6616>:
      pid.16 = pid;
      *child_pid = pid.16;
      <D.6617>:
      D.6517 = info_pipe[0];
      D.6618 = read (D.6517, &status, 4);
      if (D.6618 != 0) goto <D.6619>; else goto <D.6620>;
      <D.6619>:
      D.6517 = info_pipe[0];
      close (D.6517);
      D.6537 = in_pipe[0];
      close (D.6537);
      D.6525 = out_pipe[1];
      close (D.6525);
      D.6532 = err_pipe[1];
      close (D.6532);
      if (error != 0B) goto <D.6621>; else goto <D.6622>;
      <D.6621>:
      status.21 = status;
      D.6623 = strerror (status.21);
      status.21 = status;
      status.21 = status;
      D.6624 = monoeg_g_error_new (0B, status.21, "Error in exec (%d -> %s)", status.21, D.6623);
      *error = D.6624;
      <D.6622>:
      D.6508 = 0;
      return D.6508;
      <D.6620>:
      D.6517 = info_pipe[0];
      close (D.6517);
      if (standard_input != 0B) goto <D.6625>; else goto <D.6626>;
      <D.6625>:
      D.6538 = in_pipe[1];
      *standard_input = D.6538;
      <D.6626>:
      if (standard_output != 0B) goto <D.6627>; else goto <D.6628>;
      <D.6627>:
      D.6524 = out_pipe[0];
      *standard_output = D.6524;
      <D.6628>:
      if (standard_error != 0B) goto <D.6629>; else goto <D.6630>;
      <D.6629>:
      D.6531 = err_pipe[0];
      *standard_error = D.6531;
      <D.6630>:
      D.6508 = 1;
      return D.6508;
    }
  finally
    {
      pid = {CLOBBER};
      info_pipe = {CLOBBER};
      in_pipe = {CLOBBER};
      out_pipe = {CLOBBER};
      err_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


open (const char * __path, int __oflag)
{
  int D.6633;
  int D.6636;
  int D.6641;
  int D.6643;
  int D.6644;
  int D.6647;
  int D.6648;

  D.6633 = __builtin_va_arg_pack_len ();
  if (D.6633 > 1) goto <D.6634>; else goto <D.6635>;
  <D.6634>:
  __open_too_many_args ();
  <D.6635>:
  D.6636 = __builtin_constant_p (__oflag);
  if (D.6636 != 0) goto <D.6637>; else goto <D.6638>;
  <D.6637>:
  D.6641 = __oflag & 64;
  if (D.6641 != 0) goto <D.6639>; else goto <D.6642>;
  <D.6642>:
  D.6643 = __oflag & 4259840;
  if (D.6643 == 4259840) goto <D.6639>; else goto <D.6640>;
  <D.6639>:
  D.6644 = __builtin_va_arg_pack_len ();
  if (D.6644 <= 0) goto <D.6645>; else goto <D.6646>;
  <D.6645>:
  __open_missing_mode ();
  D.6647 = __open_2 (__path, __oflag);
  return D.6647;
  <D.6646>:
  <D.6640>:
  D.6647 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6647;
  <D.6638>:
  D.6648 = __builtin_va_arg_pack_len ();
  if (D.6648 <= 0) goto <D.6649>; else goto <D.6650>;
  <D.6649>:
  D.6647 = __open_2 (__path, __oflag);
  return D.6647;
  <D.6650>:
  D.6647 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6647;
}


write_all (int fd, const void * vbuf, size_t n)
{
  unsigned int D.6652;
  const void * D.6653;
  int * D.6655;
  int D.6656;
  int D.6659;
  unsigned int w.22;
  const char * buf;
  size_t nwritten;
  int w;

  buf = vbuf;
  nwritten = 0;
  <D.6231>:
  <D.6229>:
  D.6652 = n - nwritten;
  D.6653 = buf + nwritten;
  w = write (fd, D.6653, D.6652);
  if (w == -1) goto <D.6654>; else goto <D.6230>;
  <D.6654>:
  D.6655 = __errno_location ();
  D.6656 = *D.6655;
  if (D.6656 == 4) goto <D.6229>; else goto <D.6230>;
  <D.6230>:
  if (w == -1) goto <D.6657>; else goto <D.6658>;
  <D.6657>:
  D.6659 = -1;
  return D.6659;
  <D.6658>:
  w.22 = (unsigned int) w;
  nwritten = nwritten + w.22;
  if (nwritten < n) goto <D.6231>; else goto <D.6232>;
  <D.6232>:
  D.6659 = (int) nwritten;
  return D.6659;
}