monoeg_g_spawn_command_line_sync (const gchar * command_line, gchar * * standard_output, gchar * * standard_error, gint * exit_status, struct GError * * error)
{
  int D.6261;
  gboolean D.6264;
  int D.6267;
  int D.6272;
  int D.6277;
  int D.6278;
  int D.6285;
  int D.6286;
  int D.6287;
  gchar * * argv.0;
  gchar * D.6289;
  int D.6290;
  int * D.6305;
  int D.6306;
  union 
{
  int __in;
  int __i;
} D.6216;
  int status.1;
  int D.6308;
  int D.6309;
  union 
{
  int __in;
  int __i;
} D.6220;
  int D.6314;
  int D.6315;
  int D.6316;
  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.6261 = monoeg_g_shell_parse_argv (command_line, &argc, &argv, error);
      if (D.6261 == 0) goto <D.6262>; else goto <D.6263>;
      <D.6262>:
      D.6264 = 0;
      return D.6264;
      <D.6263>:
      if (standard_output != 0B) goto <D.6265>; else goto <D.6266>;
      <D.6265>:
      D.6267 = create_pipe (&stdout_pipe, error);
      if (D.6267 == 0) goto <D.6268>; else goto <D.6269>;
      <D.6268>:
      D.6264 = 0;
      return D.6264;
      <D.6269>:
      <D.6266>:
      if (standard_error != 0B) goto <D.6270>; else goto <D.6271>;
      <D.6270>:
      D.6272 = create_pipe (&stderr_pipe, error);
      if (D.6272 == 0) goto <D.6273>; else goto <D.6274>;
      <D.6273>:
      if (standard_output != 0B) goto <D.6275>; else goto <D.6276>;
      <D.6275>:
      D.6277 = stdout_pipe[0];
      close (D.6277);
      D.6278 = stdout_pipe[1];
      close (D.6278);
      <D.6276>:
      D.6264 = 0;
      return D.6264;
      <D.6274>:
      <D.6271>:
      pid = fork ();
      if (pid == 0) goto <D.6279>; else goto <D.6280>;
      <D.6279>:
      {
        gint i;

        if (standard_output != 0B) goto <D.6281>; else goto <D.6282>;
        <D.6281>:
        D.6277 = stdout_pipe[0];
        close (D.6277);
        D.6278 = stdout_pipe[1];
        dup2 (D.6278, 1);
        <D.6282>:
        if (standard_error != 0B) goto <D.6283>; else goto <D.6284>;
        <D.6283>:
        D.6285 = stderr_pipe[0];
        close (D.6285);
        D.6286 = stderr_pipe[1];
        dup2 (D.6286, 2);
        <D.6284>:
        D.6287 = getdtablesize ();
        i = D.6287 + -1;
        goto <D.6208>;
        <D.6207>:
        close (i);
        i = i + -1;
        <D.6208>:
        if (i > 2) goto <D.6207>; else goto <D.6209>;
        <D.6209>:
        argv.0 = argv;
        D.6289 = *argv.0;
        D.6290 = monoeg_g_path_is_absolute (D.6289);
        if (D.6290 == 0) goto <D.6291>; else goto <D.6292>;
        <D.6291>:
        {
          gchar * arg0;

          argv.0 = argv;
          D.6289 = *argv.0;
          arg0 = monoeg_g_find_program_in_path (D.6289);
          if (arg0 == 0B) goto <D.6293>; else goto <D.6294>;
          <D.6293>:
          exit (1);
          <D.6294>:
          argv.0 = argv;
          *argv.0 = arg0;
        }
        <D.6292>:
        argv.0 = argv;
        D.6289 = *argv.0;
        argv.0 = argv;
        execv (D.6289, argv.0);
        exit (1);
      }
      <D.6280>:
      argv.0 = argv;
      monoeg_g_strfreev (argv.0);
      if (standard_output != 0B) goto <D.6295>; else goto <D.6296>;
      <D.6295>:
      D.6278 = stdout_pipe[1];
      close (D.6278);
      <D.6296>:
      if (standard_error != 0B) goto <D.6297>; else goto <D.6298>;
      <D.6297>:
      D.6286 = stderr_pipe[1];
      close (D.6286);
      <D.6298>:
      if (standard_output != 0B) goto <D.6299>; else goto <D.6301>;
      <D.6301>:
      if (standard_error != 0B) goto <D.6299>; else goto <D.6300>;
      <D.6299>:
      D.6277 = stdout_pipe[0];
      D.6285 = stderr_pipe[0];
      res = read_pipes (D.6277, standard_output, D.6285, standard_error, error);
      if (res != 0) goto <D.6302>; else goto <D.6303>;
      <D.6302>:
      waitpid (pid, &status, 1);
      D.6264 = 0;
      return D.6264;
      <D.6303>:
      <D.6300>:
      <D.6211>:
      res = waitpid (pid, &status, 0);
      if (res == -1) goto <D.6304>; else goto <D.6212>;
      <D.6304>:
      D.6305 = __errno_location ();
      D.6306 = *D.6305;
      if (D.6306 == 4) goto <D.6211>; else goto <D.6212>;
      <D.6212>:
      status.1 = status;
      D.6216.__in = status.1;
      D.6308 = D.6216.__i;
      D.6309 = D.6308 & 127;
      if (D.6309 == 0) goto <D.6310>; else goto <D.6311>;
      <D.6310>:
      if (exit_status != 0B) goto <D.6312>; else goto <D.6313>;
      <D.6312>:
      {
        typedef union 
      {
        int __in;
        int __i;
      } unionunion 
      {
        int __in;
        int __i;
      };

        status.1 = status;
        D.6220.__in = status.1;
        D.6314 = D.6220.__i;
        D.6315 = D.6314 & 65280;
        D.6316 = D.6315 >> 8;
        *exit_status = D.6316;
      }
      <D.6313>:
      <D.6311>:
      D.6264 = 1;
      return D.6264;
    }
  finally
    {
      argv = {CLOBBER};
      argc = {CLOBBER};
      stdout_pipe = {CLOBBER};
      stderr_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


create_pipe (int * fds, struct GError * * error)
{
  int D.6319;
  struct GError * D.6324;
  gboolean D.6325;

  D.6319 = pipe (fds);
  if (D.6319 == -1) goto <D.6320>; else goto <D.6321>;
  <D.6320>:
  if (error != 0B) goto <D.6322>; else goto <D.6323>;
  <D.6322>:
  D.6324 = monoeg_g_error_new (0B, 1, "%s", "Error creating pipe.");
  *error = D.6324;
  <D.6323>:
  D.6325 = 0;
  return D.6325;
  <D.6321>:
  D.6325 = 1;
  return D.6325;
}


read_pipes (int outfd, gchar * * out_str, int errfd, gchar * * err_str, struct GError * * error)
{
  _Bool D.6327;
  _Bool D.6328;
  long int D.6168;
  long int iftmp.2;
  int D.6341;
  long int iftmp.3;
  unsigned int __d.4;
  long int D.6350;
  long int D.6351;
  int D.6352;
  long int D.6353;
  long int D.6354;
  long int D.6170;
  long int iftmp.5;
  int D.6360;
  long int iftmp.6;
  unsigned int __d.7;
  long int D.6369;
  long int D.6370;
  int D.6371;
  long int D.6372;
  long int D.6373;
  int D.6374;
  int D.6375;
  long int D.6172;
  long int iftmp.8;
  int D.6383;
  long int iftmp.9;
  unsigned int __d.10;
  long int D.6392;
  long int D.6393;
  long int D.6394;
  int D.6399;
  long int D.6174;
  long int iftmp.11;
  int D.6405;
  long int iftmp.12;
  unsigned int __d.13;
  long int D.6414;
  long int D.6415;
  long int D.6416;
  int * D.6425;
  int D.6426;
  gchar * D.6429;
  gchar * D.6432;
  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.6327 = outfd < 0;
      out_closed = (gboolean) D.6327;
      D.6328 = errfd < 0;
      err_closed = (gboolean) D.6328;
      if (out_str != 0B) goto <D.6329>; else goto <D.6330>;
      <D.6329>:
      *out_str = 0B;
      out = monoeg_g_string_new ("");
      <D.6330>:
      if (err_str != 0B) goto <D.6331>; else goto <D.6332>;
      <D.6331>:
      *err_str = 0B;
      err = monoeg_g_string_new ("");
      <D.6332>:
      <D.6175>:
      if (out_closed != 0) goto <D.6333>; else goto <D.6334>;
      <D.6333>:
      if (err_closed != 0) goto <D.6161>; else goto <D.6335>;
      <D.6335>:
      <D.6334>:
      {
        unsigned int __i;
        struct fd_set * __arr;

        __arr = &rfds;
        __i = 0;
        goto <D.6165>;
        <D.6164>:
        __arr->fds_bits[__i] = 0;
        __i = __i + 1;
        <D.6165>:
        if (__i <= 31) goto <D.6164>; else goto <D.6166>;
        <D.6166>:
      }
      if (out_closed == 0) goto <D.6336>; else goto <D.6337>;
      <D.6336>:
      if (outfd >= 0) goto <D.6338>; else goto <D.6339>;
      <D.6338>:
      {
        long int __d;

        __d = outfd;
        D.6341 = __builtin_constant_p (__d);
        if (D.6341 != 0) goto <D.6342>; else goto <D.6343>;
        <D.6342>:
        __d.4 = (unsigned int) __d;
        if (__d.4 <= 1023) goto <D.6346>; else goto <D.6347>;
        <D.6346>:
        iftmp.3 = __d / 32;
        goto <D.6348>;
        <D.6347>:
        iftmp.3 = __fdelt_warn (__d);
        <D.6348>:
        iftmp.2 = iftmp.3;
        goto <D.6349>;
        <D.6343>:
        iftmp.2 = __fdelt_chk (__d);
        <D.6349>:
        D.6168 = iftmp.2;
      }
      D.6350 = D.6168;
      D.6351 = rfds.fds_bits[D.6350];
      D.6352 = outfd % 32;
      D.6353 = 1 << D.6352;
      D.6354 = D.6351 | D.6353;
      rfds.fds_bits[D.6350] = D.6354;
      <D.6339>:
      <D.6337>:
      if (err_closed == 0) goto <D.6355>; else goto <D.6356>;
      <D.6355>:
      if (errfd >= 0) goto <D.6357>; else goto <D.6358>;
      <D.6357>:
      {
        long int __d;

        __d = errfd;
        D.6360 = __builtin_constant_p (__d);
        if (D.6360 != 0) goto <D.6361>; else goto <D.6362>;
        <D.6361>:
        __d.7 = (unsigned int) __d;
        if (__d.7 <= 1023) goto <D.6365>; else goto <D.6366>;
        <D.6365>:
        iftmp.6 = __d / 32;
        goto <D.6367>;
        <D.6366>:
        iftmp.6 = __fdelt_warn (__d);
        <D.6367>:
        iftmp.5 = iftmp.6;
        goto <D.6368>;
        <D.6362>:
        iftmp.5 = __fdelt_chk (__d);
        <D.6368>:
        D.6170 = iftmp.5;
      }
      D.6369 = D.6170;
      D.6370 = rfds.fds_bits[D.6369];
      D.6371 = errfd % 32;
      D.6372 = 1 << D.6371;
      D.6373 = D.6370 | D.6372;
      rfds.fds_bits[D.6369] = D.6373;
      <D.6358>:
      <D.6356>:
      D.6374 = MAX_EXPR <errfd, outfd>;
      D.6375 = D.6374 + 1;
      res = select (D.6375, &rfds, 0B, 0B, 0B);
      if (res > 0) goto <D.6376>; else goto <D.6377>;
      <D.6376>:
      if (buffer == 0B) goto <D.6378>; else goto <D.6379>;
      <D.6378>:
      buffer = monoeg_malloc (1024);
      <D.6379>:
      if (out_closed == 0) goto <D.6380>; else goto <D.6381>;
      <D.6380>:
      {
        long int __d;

        __d = outfd;
        D.6383 = __builtin_constant_p (__d);
        if (D.6383 != 0) goto <D.6384>; else goto <D.6385>;
        <D.6384>:
        __d.10 = (unsigned int) __d;
        if (__d.10 <= 1023) goto <D.6388>; else goto <D.6389>;
        <D.6388>:
        iftmp.9 = __d / 32;
        goto <D.6390>;
        <D.6389>:
        iftmp.9 = __fdelt_warn (__d);
        <D.6390>:
        iftmp.8 = iftmp.9;
        goto <D.6391>;
        <D.6385>:
        iftmp.8 = __fdelt_chk (__d);
        <D.6391>:
        D.6172 = iftmp.8;
      }
      D.6392 = rfds.fds_bits[D.6172];
      D.6352 = outfd % 32;
      D.6393 = D.6392 >> D.6352;
      D.6394 = D.6393 & 1;
      if (D.6394 != 0) goto <D.6395>; else goto <D.6396>;
      <D.6395>:
      nread = safe_read (outfd, buffer, 1024, error);
      if (nread < 0) goto <D.6397>; else goto <D.6398>;
      <D.6397>:
      close (errfd);
      close (outfd);
      D.6399 = -1;
      return D.6399;
      <D.6398>:
      monoeg_g_string_append_len (out, buffer, nread);
      if (nread <= 0) goto <D.6400>; else goto <D.6401>;
      <D.6400>:
      out_closed = 1;
      close (outfd);
      <D.6401>:
      <D.6396>:
      <D.6381>:
      if (err_closed == 0) goto <D.6402>; else goto <D.6403>;
      <D.6402>:
      {
        long int __d;

        __d = errfd;
        D.6405 = __builtin_constant_p (__d);
        if (D.6405 != 0) goto <D.6406>; else goto <D.6407>;
        <D.6406>:
        __d.13 = (unsigned int) __d;
        if (__d.13 <= 1023) goto <D.6410>; else goto <D.6411>;
        <D.6410>:
        iftmp.12 = __d / 32;
        goto <D.6412>;
        <D.6411>:
        iftmp.12 = __fdelt_warn (__d);
        <D.6412>:
        iftmp.11 = iftmp.12;
        goto <D.6413>;
        <D.6407>:
        iftmp.11 = __fdelt_chk (__d);
        <D.6413>:
        D.6174 = iftmp.11;
      }
      D.6414 = rfds.fds_bits[D.6174];
      D.6371 = errfd % 32;
      D.6415 = D.6414 >> D.6371;
      D.6416 = D.6415 & 1;
      if (D.6416 != 0) goto <D.6417>; else goto <D.6418>;
      <D.6417>:
      nread = safe_read (errfd, buffer, 1024, error);
      if (nread < 0) goto <D.6419>; else goto <D.6420>;
      <D.6419>:
      close (errfd);
      close (outfd);
      D.6399 = -1;
      return D.6399;
      <D.6420>:
      monoeg_g_string_append_len (err, buffer, nread);
      if (nread <= 0) goto <D.6421>; else goto <D.6422>;
      <D.6421>:
      err_closed = 1;
      close (errfd);
      <D.6422>:
      <D.6418>:
      <D.6403>:
      <D.6377>:
      if (res > 0) goto <D.6175>; else goto <D.6423>;
      <D.6423>:
      if (res == -1) goto <D.6424>; else goto <D.6161>;
      <D.6424>:
      D.6425 = __errno_location ();
      D.6426 = *D.6425;
      if (D.6426 == 4) goto <D.6175>; else goto <D.6161>;
      <D.6161>:
      monoeg_g_free (buffer);
      if (out_str != 0B) goto <D.6427>; else goto <D.6428>;
      <D.6427>:
      D.6429 = monoeg_g_string_free (out, 0);
      *out_str = D.6429;
      <D.6428>:
      if (err_str != 0B) goto <D.6430>; else goto <D.6431>;
      <D.6430>:
      D.6432 = monoeg_g_string_free (err, 0);
      *err_str = D.6432;
      <D.6431>:
      D.6399 = 0;
      return D.6399;
    }
  finally
    {
      rfds = {CLOBBER};
    }
}


safe_read (int fd, gchar * buffer, gint count, struct GError * * error)
{
  unsigned int count.14;
  int * D.6437;
  int D.6438;
  struct GError * D.6443;
  int D.6444;
  int res;

  <D.6144>:
  count.14 = (unsigned int) count;
  res = read (fd, buffer, count.14);
  if (res == -1) goto <D.6436>; else goto <D.6145>;
  <D.6436>:
  D.6437 = __errno_location ();
  D.6438 = *D.6437;
  if (D.6438 == 4) goto <D.6144>; else goto <D.6145>;
  <D.6145>:
  if (res == -1) goto <D.6439>; else goto <D.6440>;
  <D.6439>:
  if (error != 0B) goto <D.6441>; else goto <D.6442>;
  <D.6441>:
  D.6443 = monoeg_g_error_new (0B, 1, "%s", "Error reading from pipe.");
  *error = D.6443;
  <D.6442>:
  <D.6440>:
  D.6444 = res;
  return D.6444;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.6446;
  int D.6449;
  ssize_t D.6452;
  unsigned int D.6453;
  unsigned int D.6454;
  unsigned int D.6457;

  D.6446 = __builtin_object_size (__buf, 0);
  if (D.6446 != 4294967295) goto <D.6447>; else goto <D.6448>;
  <D.6447>:
  D.6449 = __builtin_constant_p (__nbytes);
  if (D.6449 == 0) goto <D.6450>; else goto <D.6451>;
  <D.6450>:
  D.6453 = __builtin_object_size (__buf, 0);
  D.6452 = __read_chk (__fd, __buf, __nbytes, D.6453);
  return D.6452;
  <D.6451>:
  D.6454 = __builtin_object_size (__buf, 0);
  if (D.6454 < __nbytes) goto <D.6455>; else goto <D.6456>;
  <D.6455>:
  D.6457 = __builtin_object_size (__buf, 0);
  D.6452 = __read_chk_warn (__fd, __buf, __nbytes, D.6457);
  return D.6452;
  <D.6456>:
  <D.6448>:
  D.6452 = __read_alias (__fd, __buf, __nbytes);
  return D.6452;
}


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.6461;
  int D.6462;
  int D.6467;
  int D.6470;
  int D.6471;
  int D.6474;
  int D.6477;
  int D.6478;
  int D.6481;
  int D.6484;
  int D.6485;
  int pid.15;
  int pid.16;
  int D.6490;
  int D.6491;
  struct GError * D.6494;
  unsigned int D.6497;
  int pid.17;
  _Bool D.6503;
  int D.6504;
  int pid.18;
  int * D.6509;
  int err.19;
  int D.6513;
  unsigned int D.6520;
  unsigned int D.6526;
  unsigned int D.6532;
  unsigned int D.6535;
  int D.6538;
  gchar * * iftmp.20;
  unsigned int D.6540;
  int D.6550;
  unsigned int D.6552;
  gchar * D.6553;
  int status.21;
  struct GError * D.6565;
  int D.6571;
  char * D.6576;
  struct GError * D.6577;
  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.6459>; else goto <D.6460>;
      <D.6459>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gspawn.c", 324, "argv != NULL");
      D.6461 = 0;
      return D.6461;
      <D.6460>:
      D.6462 = create_pipe (&info_pipe, error);
      if (D.6462 == 0) goto <D.6463>; else goto <D.6464>;
      <D.6463>:
      D.6461 = 0;
      return D.6461;
      <D.6464>:
      if (standard_output != 0B) goto <D.6465>; else goto <D.6466>;
      <D.6465>:
      D.6467 = create_pipe (&out_pipe, error);
      if (D.6467 == 0) goto <D.6468>; else goto <D.6469>;
      <D.6468>:
      D.6470 = info_pipe[0];
      close (D.6470);
      D.6471 = info_pipe[1];
      close (D.6471);
      D.6461 = 0;
      return D.6461;
      <D.6469>:
      <D.6466>:
      if (standard_error != 0B) goto <D.6472>; else goto <D.6473>;
      <D.6472>:
      D.6474 = create_pipe (&err_pipe, error);
      if (D.6474 == 0) goto <D.6475>; else goto <D.6476>;
      <D.6475>:
      D.6470 = info_pipe[0];
      close (D.6470);
      D.6471 = info_pipe[1];
      close (D.6471);
      D.6477 = out_pipe[0];
      close (D.6477);
      D.6478 = out_pipe[1];
      close (D.6478);
      D.6461 = 0;
      return D.6461;
      <D.6476>:
      <D.6473>:
      if (standard_input != 0B) goto <D.6479>; else goto <D.6480>;
      <D.6479>:
      D.6481 = create_pipe (&in_pipe, error);
      if (D.6481 == 0) goto <D.6482>; else goto <D.6483>;
      <D.6482>:
      D.6470 = info_pipe[0];
      close (D.6470);
      D.6471 = info_pipe[1];
      close (D.6471);
      D.6477 = out_pipe[0];
      close (D.6477);
      D.6478 = out_pipe[1];
      close (D.6478);
      D.6484 = err_pipe[0];
      close (D.6484);
      D.6485 = err_pipe[1];
      close (D.6485);
      D.6461 = 0;
      return D.6461;
      <D.6483>:
      <D.6480>:
      pid.15 = fork ();
      pid = pid.15;
      pid.16 = pid;
      if (pid.16 == -1) goto <D.6488>; else goto <D.6489>;
      <D.6488>:
      D.6470 = info_pipe[0];
      close (D.6470);
      D.6471 = info_pipe[1];
      close (D.6471);
      D.6477 = out_pipe[0];
      close (D.6477);
      D.6478 = out_pipe[1];
      close (D.6478);
      D.6484 = err_pipe[0];
      close (D.6484);
      D.6485 = err_pipe[1];
      close (D.6485);
      D.6490 = in_pipe[0];
      close (D.6490);
      D.6491 = in_pipe[1];
      close (D.6491);
      if (error != 0B) goto <D.6492>; else goto <D.6493>;
      <D.6492>:
      D.6494 = monoeg_g_error_new (0B, 1, "%s", "Error in fork ()");
      *error = D.6494;
      <D.6493>:
      D.6461 = 0;
      return D.6461;
      <D.6489>:
      pid.16 = pid;
      if (pid.16 == 0) goto <D.6495>; else goto <D.6496>;
      <D.6495>:
      D.6497 = flags & 2;
      if (D.6497 == 0) goto <D.6498>; else goto <D.6499>;
      <D.6498>:
      pid.17 = fork ();
      pid = pid.17;
      <D.6499>:
      pid.16 = pid;
      if (pid.16 != 0) goto <D.6501>; else goto <D.6502>;
      <D.6501>:
      pid.16 = pid;
      D.6503 = pid.16 == -1;
      D.6504 = (int) D.6503;
      exit (D.6504);
      <D.6502>:
      {
        gint i;
        int fd;
        gchar * arg0;
        gchar * * actual_args;
        gint unused;

        D.6470 = info_pipe[0];
        close (D.6470);
        D.6491 = in_pipe[1];
        close (D.6491);
        D.6477 = out_pipe[0];
        close (D.6477);
        D.6484 = err_pipe[0];
        close (D.6484);
        D.6471 = info_pipe[1];
        fcntl (D.6471, 2, 1);
        D.6497 = flags & 2;
        if (D.6497 == 0) goto <D.6505>; else goto <D.6506>;
        <D.6505>:
        pid.18 = getpid ();
        pid = pid.18;
        <D.6245>:
        D.6471 = info_pipe[1];
        unused = write_all (D.6471, &pid, 4);
        if (unused == -1) goto <D.6508>; else goto <D.6246>;
        <D.6508>:
        D.6509 = __errno_location ();
        err.19 = *D.6509;
        if (err.19 == 4) goto <D.6245>; else goto <D.6246>;
        <D.6246>:
        <D.6506>:
        if (working_directory != 0B) goto <D.6511>; else goto <D.6512>;
        <D.6511>:
        D.6513 = chdir (working_directory);
        if (D.6513 == -1) goto <D.6514>; else goto <D.6515>;
        <D.6514>:
        {
          int err;

          try
            {
              D.6509 = __errno_location ();
              err.19 = *D.6509;
              err = err.19;
              <D.6248>:
              D.6471 = info_pipe[1];
              unused = write_all (D.6471, &err, 4);
              if (unused == -1) goto <D.6516>; else goto <D.6249>;
              <D.6516>:
              D.6509 = __errno_location ();
              err.19 = *D.6509;
              if (err.19 == 4) goto <D.6248>; else goto <D.6249>;
              <D.6249>:
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6515>:
        <D.6512>:
        if (standard_output != 0B) goto <D.6517>; else goto <D.6518>;
        <D.6517>:
        D.6478 = out_pipe[1];
        dup2 (D.6478, 1);
        goto <D.6519>;
        <D.6518>:
        D.6520 = flags & 8;
        if (D.6520 != 0) goto <D.6521>; else goto <D.6522>;
        <D.6521>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 1);
        <D.6522>:
        <D.6519>:
        if (standard_error != 0B) goto <D.6523>; else goto <D.6524>;
        <D.6523>:
        D.6485 = err_pipe[1];
        dup2 (D.6485, 2);
        goto <D.6525>;
        <D.6524>:
        D.6526 = flags & 16;
        if (D.6526 != 0) goto <D.6527>; else goto <D.6528>;
        <D.6527>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 2);
        <D.6528>:
        <D.6525>:
        if (standard_input != 0B) goto <D.6529>; else goto <D.6530>;
        <D.6529>:
        D.6490 = in_pipe[0];
        dup2 (D.6490, 0);
        goto <D.6531>;
        <D.6530>:
        D.6532 = flags & 32;
        if (D.6532 == 0) goto <D.6533>; else goto <D.6534>;
        <D.6533>:
        fd = open ("/dev/null", 0);
        dup2 (fd, 0);
        <D.6534>:
        <D.6531>:
        D.6535 = flags & 1;
        if (D.6535 != 0) goto <D.6536>; else goto <D.6537>;
        <D.6536>:
        D.6538 = getdtablesize ();
        i = D.6538 + -1;
        goto <D.6251>;
        <D.6250>:
        close (i);
        i = i + -1;
        <D.6251>:
        if (i > 2) goto <D.6250>; else goto <D.6252>;
        <D.6252>:
        <D.6537>:
        D.6540 = flags & 64;
        if (D.6540 != 0) goto <D.6541>; else goto <D.6542>;
        <D.6541>:
        iftmp.20 = argv + 4;
        goto <D.6543>;
        <D.6542>:
        iftmp.20 = argv;
        <D.6543>:
        actual_args = iftmp.20;
        if (envp == 0B) goto <D.6544>; else goto <D.6545>;
        <D.6544>:
        envp = environ;
        <D.6545>:
        if (child_setup != 0B) goto <D.6546>; else goto <D.6547>;
        <D.6546>:
        child_setup (user_data);
        <D.6547>:
        arg0 = *argv;
        D.6550 = monoeg_g_path_is_absolute (arg0);
        if (D.6550 == 0) goto <D.6548>; else goto <D.6551>;
        <D.6551>:
        D.6552 = flags & 4;
        if (D.6552 != 0) goto <D.6548>; else goto <D.6549>;
        <D.6548>:
        D.6553 = *argv;
        arg0 = monoeg_g_find_program_in_path (D.6553);
        if (arg0 == 0B) goto <D.6554>; else goto <D.6555>;
        <D.6554>:
        {
          int err;

          try
            {
              err = 2;
              D.6471 = info_pipe[1];
              write_all (D.6471, &err, 4);
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6555>:
        <D.6549>:
        execve (arg0, actual_args, envp);
        D.6471 = info_pipe[1];
        D.6509 = __errno_location ();
        write_all (D.6471, D.6509, 4);
        exit (0);
      }
      <D.6496>:
      D.6497 = flags & 2;
      if (D.6497 == 0) goto <D.6556>; else goto <D.6557>;
      <D.6556>:
      {
        int w;

        <D.6255>:
        pid.16 = pid;
        w = waitpid (pid.16, &status, 0);
        if (w == -1) goto <D.6558>; else goto <D.6256>;
        <D.6558>:
        D.6509 = __errno_location ();
        err.19 = *D.6509;
        if (err.19 == 4) goto <D.6255>; else goto <D.6256>;
        <D.6256>:
        status.21 = status;
        if (status.21 == 1) goto <D.6559>; else goto <D.6562>;
        <D.6562>:
        if (w == -1) goto <D.6559>; else goto <D.6560>;
        <D.6559>:
        D.6470 = info_pipe[0];
        close (D.6470);
        D.6471 = info_pipe[1];
        close (D.6471);
        D.6477 = out_pipe[0];
        close (D.6477);
        D.6478 = out_pipe[1];
        close (D.6478);
        D.6484 = err_pipe[0];
        close (D.6484);
        D.6485 = err_pipe[1];
        close (D.6485);
        D.6490 = in_pipe[0];
        close (D.6490);
        D.6491 = in_pipe[1];
        close (D.6491);
        if (error != 0B) goto <D.6563>; else goto <D.6564>;
        <D.6563>:
        status.21 = status;
        D.6565 = monoeg_g_error_new (0B, 1, "Error in fork (): %d", status.21);
        *error = D.6565;
        <D.6564>:
        D.6461 = 0;
        return D.6461;
        <D.6560>:
      }
      <D.6557>:
      D.6471 = info_pipe[1];
      close (D.6471);
      D.6490 = in_pipe[0];
      close (D.6490);
      D.6478 = out_pipe[1];
      close (D.6478);
      D.6485 = err_pipe[1];
      close (D.6485);
      D.6497 = flags & 2;
      if (D.6497 == 0) goto <D.6566>; else goto <D.6567>;
      <D.6566>:
      {
        int x;

        <D.6258>:
        D.6470 = info_pipe[0];
        x = read (D.6470, &pid, 4);
        if (x == -1) goto <D.6568>; else goto <D.6259>;
        <D.6568>:
        D.6509 = __errno_location ();
        err.19 = *D.6509;
        if (err.19 == 4) goto <D.6258>; else goto <D.6259>;
        <D.6259>:
      }
      <D.6567>:
      if (child_pid != 0B) goto <D.6569>; else goto <D.6570>;
      <D.6569>:
      pid.16 = pid;
      *child_pid = pid.16;
      <D.6570>:
      D.6470 = info_pipe[0];
      D.6571 = read (D.6470, &status, 4);
      if (D.6571 != 0) goto <D.6572>; else goto <D.6573>;
      <D.6572>:
      D.6470 = info_pipe[0];
      close (D.6470);
      D.6490 = in_pipe[0];
      close (D.6490);
      D.6478 = out_pipe[1];
      close (D.6478);
      D.6485 = err_pipe[1];
      close (D.6485);
      if (error != 0B) goto <D.6574>; else goto <D.6575>;
      <D.6574>:
      status.21 = status;
      status.21 = status;
      status.21 = status;
      D.6576 = strerror (status.21);
      D.6577 = monoeg_g_error_new (0B, status.21, "Error in exec (%d -> %s)", status.21, D.6576);
      *error = D.6577;
      <D.6575>:
      D.6461 = 0;
      return D.6461;
      <D.6573>:
      D.6470 = info_pipe[0];
      close (D.6470);
      if (standard_input != 0B) goto <D.6578>; else goto <D.6579>;
      <D.6578>:
      D.6491 = in_pipe[1];
      *standard_input = D.6491;
      <D.6579>:
      if (standard_output != 0B) goto <D.6580>; else goto <D.6581>;
      <D.6580>:
      D.6477 = out_pipe[0];
      *standard_output = D.6477;
      <D.6581>:
      if (standard_error != 0B) goto <D.6582>; else goto <D.6583>;
      <D.6582>:
      D.6484 = err_pipe[0];
      *standard_error = D.6484;
      <D.6583>:
      D.6461 = 1;
      return D.6461;
    }
  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.6586;
  int D.6589;
  int D.6594;
  int D.6596;
  int D.6597;
  int D.6600;
  int D.6601;

  D.6586 = __builtin_va_arg_pack_len ();
  if (D.6586 > 1) goto <D.6587>; else goto <D.6588>;
  <D.6587>:
  __open_too_many_args ();
  <D.6588>:
  D.6589 = __builtin_constant_p (__oflag);
  if (D.6589 != 0) goto <D.6590>; else goto <D.6591>;
  <D.6590>:
  D.6594 = __oflag & 256;
  if (D.6594 != 0) goto <D.6592>; else goto <D.6595>;
  <D.6595>:
  D.6596 = __oflag & 4259840;
  if (D.6596 == 4259840) goto <D.6592>; else goto <D.6593>;
  <D.6592>:
  D.6597 = __builtin_va_arg_pack_len ();
  if (D.6597 <= 0) goto <D.6598>; else goto <D.6599>;
  <D.6598>:
  __open_missing_mode ();
  D.6600 = __open_2 (__path, __oflag);
  return D.6600;
  <D.6599>:
  <D.6593>:
  D.6600 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6600;
  <D.6591>:
  D.6601 = __builtin_va_arg_pack_len ();
  if (D.6601 <= 0) goto <D.6602>; else goto <D.6603>;
  <D.6602>:
  D.6600 = __open_2 (__path, __oflag);
  return D.6600;
  <D.6603>:
  D.6600 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6600;
}


write_all (int fd, const void * vbuf, size_t n)
{
  const void * D.6605;
  unsigned int D.6606;
  int * D.6608;
  int D.6609;
  int D.6612;
  unsigned int w.22;
  const char * buf;
  size_t nwritten;
  int w;

  buf = vbuf;
  nwritten = 0;
  <D.6190>:
  <D.6188>:
  D.6605 = buf + nwritten;
  D.6606 = n - nwritten;
  w = write (fd, D.6605, D.6606);
  if (w == -1) goto <D.6607>; else goto <D.6189>;
  <D.6607>:
  D.6608 = __errno_location ();
  D.6609 = *D.6608;
  if (D.6609 == 4) goto <D.6188>; else goto <D.6189>;
  <D.6189>:
  if (w == -1) goto <D.6610>; else goto <D.6611>;
  <D.6610>:
  D.6612 = -1;
  return D.6612;
  <D.6611>:
  w.22 = (unsigned int) w;
  nwritten = nwritten + w.22;
  if (nwritten < n) goto <D.6190>; else goto <D.6191>;
  <D.6191>:
  D.6612 = (int) nwritten;
  return D.6612;
}