monoeg_g_spawn_command_line_sync (const gchar * command_line, gchar * * standard_output, gchar * * standard_error, gint * exit_status, struct GError * * error)
{
  int D.7192;
  gboolean D.7195;
  int D.7198;
  int D.7203;
  int D.7208;
  int D.7209;
  int D.7216;
  int D.7217;
  int D.7218;
  gchar * * argv.0;
  gchar * D.7220;
  int D.7221;
  int * D.7236;
  int D.7237;
  union 
{
  int __in;
  int __i;
} D.7147;
  int status.1;
  int D.7239;
  int D.7240;
  union 
{
  int __in;
  int __i;
} D.7151;
  int D.7245;
  int D.7246;
  int D.7247;
  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.7192 = monoeg_g_shell_parse_argv (command_line, &argc, &argv, error);
      if (D.7192 == 0) goto <D.7193>; else goto <D.7194>;
      <D.7193>:
      D.7195 = 0;
      return D.7195;
      <D.7194>:
      if (standard_output != 0B) goto <D.7196>; else goto <D.7197>;
      <D.7196>:
      D.7198 = create_pipe (&stdout_pipe, error);
      if (D.7198 == 0) goto <D.7199>; else goto <D.7200>;
      <D.7199>:
      D.7195 = 0;
      return D.7195;
      <D.7200>:
      <D.7197>:
      if (standard_error != 0B) goto <D.7201>; else goto <D.7202>;
      <D.7201>:
      D.7203 = create_pipe (&stderr_pipe, error);
      if (D.7203 == 0) goto <D.7204>; else goto <D.7205>;
      <D.7204>:
      if (standard_output != 0B) goto <D.7206>; else goto <D.7207>;
      <D.7206>:
      D.7208 = stdout_pipe[0];
      close (D.7208);
      D.7209 = stdout_pipe[1];
      close (D.7209);
      <D.7207>:
      D.7195 = 0;
      return D.7195;
      <D.7205>:
      <D.7202>:
      pid = fork ();
      if (pid == 0) goto <D.7210>; else goto <D.7211>;
      <D.7210>:
      {
        gint i;

        if (standard_output != 0B) goto <D.7212>; else goto <D.7213>;
        <D.7212>:
        D.7208 = stdout_pipe[0];
        close (D.7208);
        D.7209 = stdout_pipe[1];
        dup2 (D.7209, 1);
        <D.7213>:
        if (standard_error != 0B) goto <D.7214>; else goto <D.7215>;
        <D.7214>:
        D.7216 = stderr_pipe[0];
        close (D.7216);
        D.7217 = stderr_pipe[1];
        dup2 (D.7217, 2);
        <D.7215>:
        D.7218 = getdtablesize ();
        i = D.7218 + -1;
        goto <D.7139>;
        <D.7138>:
        close (i);
        i = i + -1;
        <D.7139>:
        if (i > 2) goto <D.7138>; else goto <D.7140>;
        <D.7140>:
        argv.0 = argv;
        D.7220 = *argv.0;
        D.7221 = monoeg_g_path_is_absolute (D.7220);
        if (D.7221 == 0) goto <D.7222>; else goto <D.7223>;
        <D.7222>:
        {
          gchar * arg0;

          argv.0 = argv;
          D.7220 = *argv.0;
          arg0 = monoeg_g_find_program_in_path (D.7220);
          if (arg0 == 0B) goto <D.7224>; else goto <D.7225>;
          <D.7224>:
          exit (1);
          <D.7225>:
          argv.0 = argv;
          *argv.0 = arg0;
        }
        <D.7223>:
        argv.0 = argv;
        D.7220 = *argv.0;
        argv.0 = argv;
        execv (D.7220, argv.0);
        exit (1);
      }
      <D.7211>:
      argv.0 = argv;
      monoeg_g_strfreev (argv.0);
      if (standard_output != 0B) goto <D.7226>; else goto <D.7227>;
      <D.7226>:
      D.7209 = stdout_pipe[1];
      close (D.7209);
      <D.7227>:
      if (standard_error != 0B) goto <D.7228>; else goto <D.7229>;
      <D.7228>:
      D.7217 = stderr_pipe[1];
      close (D.7217);
      <D.7229>:
      if (standard_output != 0B) goto <D.7230>; else goto <D.7232>;
      <D.7232>:
      if (standard_error != 0B) goto <D.7230>; else goto <D.7231>;
      <D.7230>:
      D.7208 = stdout_pipe[0];
      D.7216 = stderr_pipe[0];
      res = read_pipes (D.7208, standard_output, D.7216, standard_error, error);
      if (res != 0) goto <D.7233>; else goto <D.7234>;
      <D.7233>:
      waitpid (pid, &status, 1);
      D.7195 = 0;
      return D.7195;
      <D.7234>:
      <D.7231>:
      <D.7142>:
      res = waitpid (pid, &status, 0);
      if (res == -1) goto <D.7235>; else goto <D.7143>;
      <D.7235>:
      D.7236 = __errno_location ();
      D.7237 = *D.7236;
      if (D.7237 == 4) goto <D.7142>; else goto <D.7143>;
      <D.7143>:
      status.1 = status;
      D.7147.__in = status.1;
      D.7239 = D.7147.__i;
      D.7240 = D.7239 & 127;
      if (D.7240 == 0) goto <D.7241>; else goto <D.7242>;
      <D.7241>:
      if (exit_status != 0B) goto <D.7243>; else goto <D.7244>;
      <D.7243>:
      {
        typedef union 
      {
        int __in;
        int __i;
      } unionunion 
      {
        int __in;
        int __i;
      };

        status.1 = status;
        D.7151.__in = status.1;
        D.7245 = D.7151.__i;
        D.7246 = D.7245 & 65280;
        D.7247 = D.7246 >> 8;
        *exit_status = D.7247;
      }
      <D.7244>:
      <D.7242>:
      D.7195 = 1;
      return D.7195;
    }
  finally
    {
      argv = {CLOBBER};
      argc = {CLOBBER};
      stdout_pipe = {CLOBBER};
      stderr_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


create_pipe (int * fds, struct GError * * error)
{
  int D.7250;
  struct GError * D.7255;
  gboolean D.7256;

  D.7250 = pipe (fds);
  if (D.7250 == -1) goto <D.7251>; else goto <D.7252>;
  <D.7251>:
  if (error != 0B) goto <D.7253>; else goto <D.7254>;
  <D.7253>:
  D.7255 = monoeg_g_error_new (0B, 1, "%s", "Error creating pipe.");
  *error = D.7255;
  <D.7254>:
  D.7256 = 0;
  return D.7256;
  <D.7252>:
  D.7256 = 1;
  return D.7256;
}


read_pipes (int outfd, gchar * * out_str, int errfd, gchar * * err_str, struct GError * * error)
{
  _Bool D.7258;
  _Bool D.7259;
  long int D.7099;
  long int iftmp.2;
  int D.7272;
  long int iftmp.3;
  unsigned long __d.4;
  long int D.7281;
  long int D.7282;
  int D.7283;
  long int D.7284;
  long int D.7285;
  long int D.7101;
  long int iftmp.5;
  int D.7291;
  long int iftmp.6;
  unsigned long __d.7;
  long int D.7300;
  long int D.7301;
  int D.7302;
  long int D.7303;
  long int D.7304;
  int D.7305;
  int D.7306;
  long int D.7103;
  long int iftmp.8;
  int D.7314;
  long int iftmp.9;
  unsigned long __d.10;
  long int D.7323;
  long int D.7324;
  long int D.7325;
  int D.7330;
  long int D.7331;
  long int D.7105;
  long int iftmp.11;
  int D.7337;
  long int iftmp.12;
  unsigned long __d.13;
  long int D.7346;
  long int D.7347;
  long int D.7348;
  int * D.7357;
  int D.7358;
  gchar * D.7361;
  gchar * D.7364;
  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.7258 = outfd < 0;
      out_closed = (gboolean) D.7258;
      D.7259 = errfd < 0;
      err_closed = (gboolean) D.7259;
      if (out_str != 0B) goto <D.7260>; else goto <D.7261>;
      <D.7260>:
      *out_str = 0B;
      out = monoeg_g_string_new ("");
      <D.7261>:
      if (err_str != 0B) goto <D.7262>; else goto <D.7263>;
      <D.7262>:
      *err_str = 0B;
      err = monoeg_g_string_new ("");
      <D.7263>:
      <D.7106>:
      if (out_closed != 0) goto <D.7264>; else goto <D.7265>;
      <D.7264>:
      if (err_closed != 0) goto <D.7092>; else goto <D.7266>;
      <D.7266>:
      <D.7265>:
      {
        unsigned int __i;
        struct fd_set * __arr;

        __arr = &rfds;
        __i = 0;
        goto <D.7096>;
        <D.7095>:
        __arr->fds_bits[__i] = 0;
        __i = __i + 1;
        <D.7096>:
        if (__i <= 15) goto <D.7095>; else goto <D.7097>;
        <D.7097>:
      }
      if (out_closed == 0) goto <D.7267>; else goto <D.7268>;
      <D.7267>:
      if (outfd >= 0) goto <D.7269>; else goto <D.7270>;
      <D.7269>:
      {
        long int __d;

        __d = (long int) outfd;
        D.7272 = __builtin_constant_p (__d);
        if (D.7272 != 0) goto <D.7273>; else goto <D.7274>;
        <D.7273>:
        __d.4 = (unsigned long) __d;
        if (__d.4 <= 1023) goto <D.7277>; else goto <D.7278>;
        <D.7277>:
        iftmp.3 = __d / 64;
        goto <D.7279>;
        <D.7278>:
        iftmp.3 = __fdelt_warn (__d);
        <D.7279>:
        iftmp.2 = iftmp.3;
        goto <D.7280>;
        <D.7274>:
        iftmp.2 = __fdelt_chk (__d);
        <D.7280>:
        D.7099 = iftmp.2;
      }
      D.7281 = D.7099;
      D.7282 = rfds.fds_bits[D.7281];
      D.7283 = outfd % 64;
      D.7284 = 1 << D.7283;
      D.7285 = D.7282 | D.7284;
      rfds.fds_bits[D.7281] = D.7285;
      <D.7270>:
      <D.7268>:
      if (err_closed == 0) goto <D.7286>; else goto <D.7287>;
      <D.7286>:
      if (errfd >= 0) goto <D.7288>; else goto <D.7289>;
      <D.7288>:
      {
        long int __d;

        __d = (long int) errfd;
        D.7291 = __builtin_constant_p (__d);
        if (D.7291 != 0) goto <D.7292>; else goto <D.7293>;
        <D.7292>:
        __d.7 = (unsigned long) __d;
        if (__d.7 <= 1023) goto <D.7296>; else goto <D.7297>;
        <D.7296>:
        iftmp.6 = __d / 64;
        goto <D.7298>;
        <D.7297>:
        iftmp.6 = __fdelt_warn (__d);
        <D.7298>:
        iftmp.5 = iftmp.6;
        goto <D.7299>;
        <D.7293>:
        iftmp.5 = __fdelt_chk (__d);
        <D.7299>:
        D.7101 = iftmp.5;
      }
      D.7300 = D.7101;
      D.7301 = rfds.fds_bits[D.7300];
      D.7302 = errfd % 64;
      D.7303 = 1 << D.7302;
      D.7304 = D.7301 | D.7303;
      rfds.fds_bits[D.7300] = D.7304;
      <D.7289>:
      <D.7287>:
      D.7305 = MAX_EXPR <errfd, outfd>;
      D.7306 = D.7305 + 1;
      res = select (D.7306, &rfds, 0B, 0B, 0B);
      if (res > 0) goto <D.7307>; else goto <D.7308>;
      <D.7307>:
      if (buffer == 0B) goto <D.7309>; else goto <D.7310>;
      <D.7309>:
      buffer = monoeg_malloc (1024);
      <D.7310>:
      if (out_closed == 0) goto <D.7311>; else goto <D.7312>;
      <D.7311>:
      {
        long int __d;

        __d = (long int) outfd;
        D.7314 = __builtin_constant_p (__d);
        if (D.7314 != 0) goto <D.7315>; else goto <D.7316>;
        <D.7315>:
        __d.10 = (unsigned long) __d;
        if (__d.10 <= 1023) goto <D.7319>; else goto <D.7320>;
        <D.7319>:
        iftmp.9 = __d / 64;
        goto <D.7321>;
        <D.7320>:
        iftmp.9 = __fdelt_warn (__d);
        <D.7321>:
        iftmp.8 = iftmp.9;
        goto <D.7322>;
        <D.7316>:
        iftmp.8 = __fdelt_chk (__d);
        <D.7322>:
        D.7103 = iftmp.8;
      }
      D.7323 = rfds.fds_bits[D.7103];
      D.7283 = outfd % 64;
      D.7324 = D.7323 >> D.7283;
      D.7325 = D.7324 & 1;
      if (D.7325 != 0) goto <D.7326>; else goto <D.7327>;
      <D.7326>:
      nread = safe_read (outfd, buffer, 1024, error);
      if (nread < 0) goto <D.7328>; else goto <D.7329>;
      <D.7328>:
      close (errfd);
      close (outfd);
      D.7330 = -1;
      return D.7330;
      <D.7329>:
      D.7331 = (long int) nread;
      monoeg_g_string_append_len (out, buffer, D.7331);
      if (nread <= 0) goto <D.7332>; else goto <D.7333>;
      <D.7332>:
      out_closed = 1;
      close (outfd);
      <D.7333>:
      <D.7327>:
      <D.7312>:
      if (err_closed == 0) goto <D.7334>; else goto <D.7335>;
      <D.7334>:
      {
        long int __d;

        __d = (long int) errfd;
        D.7337 = __builtin_constant_p (__d);
        if (D.7337 != 0) goto <D.7338>; else goto <D.7339>;
        <D.7338>:
        __d.13 = (unsigned long) __d;
        if (__d.13 <= 1023) goto <D.7342>; else goto <D.7343>;
        <D.7342>:
        iftmp.12 = __d / 64;
        goto <D.7344>;
        <D.7343>:
        iftmp.12 = __fdelt_warn (__d);
        <D.7344>:
        iftmp.11 = iftmp.12;
        goto <D.7345>;
        <D.7339>:
        iftmp.11 = __fdelt_chk (__d);
        <D.7345>:
        D.7105 = iftmp.11;
      }
      D.7346 = rfds.fds_bits[D.7105];
      D.7302 = errfd % 64;
      D.7347 = D.7346 >> D.7302;
      D.7348 = D.7347 & 1;
      if (D.7348 != 0) goto <D.7349>; else goto <D.7350>;
      <D.7349>:
      nread = safe_read (errfd, buffer, 1024, error);
      if (nread < 0) goto <D.7351>; else goto <D.7352>;
      <D.7351>:
      close (errfd);
      close (outfd);
      D.7330 = -1;
      return D.7330;
      <D.7352>:
      D.7331 = (long int) nread;
      monoeg_g_string_append_len (err, buffer, D.7331);
      if (nread <= 0) goto <D.7353>; else goto <D.7354>;
      <D.7353>:
      err_closed = 1;
      close (errfd);
      <D.7354>:
      <D.7350>:
      <D.7335>:
      <D.7308>:
      if (res > 0) goto <D.7106>; else goto <D.7355>;
      <D.7355>:
      if (res == -1) goto <D.7356>; else goto <D.7092>;
      <D.7356>:
      D.7357 = __errno_location ();
      D.7358 = *D.7357;
      if (D.7358 == 4) goto <D.7106>; else goto <D.7092>;
      <D.7092>:
      monoeg_g_free (buffer);
      if (out_str != 0B) goto <D.7359>; else goto <D.7360>;
      <D.7359>:
      D.7361 = monoeg_g_string_free (out, 0);
      *out_str = D.7361;
      <D.7360>:
      if (err_str != 0B) goto <D.7362>; else goto <D.7363>;
      <D.7362>:
      D.7364 = monoeg_g_string_free (err, 0);
      *err_str = D.7364;
      <D.7363>:
      D.7330 = 0;
      return D.7330;
    }
  finally
    {
      rfds = {CLOBBER};
    }
}


safe_read (int fd, gchar * buffer, gint count, struct GError * * error)
{
  long unsigned int D.7367;
  long int D.7368;
  int * D.7370;
  int D.7371;
  struct GError * D.7376;
  int D.7377;
  int res;

  <D.7075>:
  D.7367 = (long unsigned int) count;
  D.7368 = read (fd, buffer, D.7367);
  res = (int) D.7368;
  if (res == -1) goto <D.7369>; else goto <D.7076>;
  <D.7369>:
  D.7370 = __errno_location ();
  D.7371 = *D.7370;
  if (D.7371 == 4) goto <D.7075>; else goto <D.7076>;
  <D.7076>:
  if (res == -1) goto <D.7372>; else goto <D.7373>;
  <D.7372>:
  if (error != 0B) goto <D.7374>; else goto <D.7375>;
  <D.7374>:
  D.7376 = monoeg_g_error_new (0B, 1, "%s", "Error reading from pipe.");
  *error = D.7376;
  <D.7375>:
  <D.7373>:
  D.7377 = res;
  return D.7377;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.7379;
  int D.7382;
  ssize_t D.7385;
  long unsigned int D.7386;
  long unsigned int D.7387;
  long unsigned int D.7390;

  D.7379 = __builtin_object_size (__buf, 0);
  if (D.7379 != 18446744073709551615) goto <D.7380>; else goto <D.7381>;
  <D.7380>:
  D.7382 = __builtin_constant_p (__nbytes);
  if (D.7382 == 0) goto <D.7383>; else goto <D.7384>;
  <D.7383>:
  D.7386 = __builtin_object_size (__buf, 0);
  D.7385 = __read_chk (__fd, __buf, __nbytes, D.7386);
  return D.7385;
  <D.7384>:
  D.7387 = __builtin_object_size (__buf, 0);
  if (D.7387 < __nbytes) goto <D.7388>; else goto <D.7389>;
  <D.7388>:
  D.7390 = __builtin_object_size (__buf, 0);
  D.7385 = __read_chk_warn (__fd, __buf, __nbytes, D.7390);
  return D.7385;
  <D.7389>:
  <D.7381>:
  D.7385 = __read_alias (__fd, __buf, __nbytes);
  return D.7385;
}


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.7394;
  int D.7395;
  int D.7400;
  int D.7403;
  int D.7404;
  int D.7407;
  int D.7410;
  int D.7411;
  int D.7414;
  int D.7417;
  int D.7418;
  int pid.14;
  int pid.15;
  int D.7423;
  int D.7424;
  struct GError * D.7427;
  unsigned int D.7430;
  int pid.16;
  _Bool D.7436;
  int D.7437;
  int pid.17;
  int * D.7442;
  int err.18;
  int D.7446;
  unsigned int D.7453;
  unsigned int D.7459;
  unsigned int D.7465;
  unsigned int D.7468;
  int D.7471;
  gchar * * iftmp.19;
  unsigned int D.7473;
  int D.7483;
  unsigned int D.7485;
  gchar * D.7486;
  int status.20;
  struct GError * D.7498;
  long int D.7501;
  long int D.7505;
  char * D.7510;
  struct GError * D.7511;
  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.7392>; else goto <D.7393>;
      <D.7392>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gspawn.c", 324, "argv != NULL");
      D.7394 = 0;
      return D.7394;
      <D.7393>:
      D.7395 = create_pipe (&info_pipe, error);
      if (D.7395 == 0) goto <D.7396>; else goto <D.7397>;
      <D.7396>:
      D.7394 = 0;
      return D.7394;
      <D.7397>:
      if (standard_output != 0B) goto <D.7398>; else goto <D.7399>;
      <D.7398>:
      D.7400 = create_pipe (&out_pipe, error);
      if (D.7400 == 0) goto <D.7401>; else goto <D.7402>;
      <D.7401>:
      D.7403 = info_pipe[0];
      close (D.7403);
      D.7404 = info_pipe[1];
      close (D.7404);
      D.7394 = 0;
      return D.7394;
      <D.7402>:
      <D.7399>:
      if (standard_error != 0B) goto <D.7405>; else goto <D.7406>;
      <D.7405>:
      D.7407 = create_pipe (&err_pipe, error);
      if (D.7407 == 0) goto <D.7408>; else goto <D.7409>;
      <D.7408>:
      D.7403 = info_pipe[0];
      close (D.7403);
      D.7404 = info_pipe[1];
      close (D.7404);
      D.7410 = out_pipe[0];
      close (D.7410);
      D.7411 = out_pipe[1];
      close (D.7411);
      D.7394 = 0;
      return D.7394;
      <D.7409>:
      <D.7406>:
      if (standard_input != 0B) goto <D.7412>; else goto <D.7413>;
      <D.7412>:
      D.7414 = create_pipe (&in_pipe, error);
      if (D.7414 == 0) goto <D.7415>; else goto <D.7416>;
      <D.7415>:
      D.7403 = info_pipe[0];
      close (D.7403);
      D.7404 = info_pipe[1];
      close (D.7404);
      D.7410 = out_pipe[0];
      close (D.7410);
      D.7411 = out_pipe[1];
      close (D.7411);
      D.7417 = err_pipe[0];
      close (D.7417);
      D.7418 = err_pipe[1];
      close (D.7418);
      D.7394 = 0;
      return D.7394;
      <D.7416>:
      <D.7413>:
      pid.14 = fork ();
      pid = pid.14;
      pid.15 = pid;
      if (pid.15 == -1) goto <D.7421>; else goto <D.7422>;
      <D.7421>:
      D.7403 = info_pipe[0];
      close (D.7403);
      D.7404 = info_pipe[1];
      close (D.7404);
      D.7410 = out_pipe[0];
      close (D.7410);
      D.7411 = out_pipe[1];
      close (D.7411);
      D.7417 = err_pipe[0];
      close (D.7417);
      D.7418 = err_pipe[1];
      close (D.7418);
      D.7423 = in_pipe[0];
      close (D.7423);
      D.7424 = in_pipe[1];
      close (D.7424);
      if (error != 0B) goto <D.7425>; else goto <D.7426>;
      <D.7425>:
      D.7427 = monoeg_g_error_new (0B, 1, "%s", "Error in fork ()");
      *error = D.7427;
      <D.7426>:
      D.7394 = 0;
      return D.7394;
      <D.7422>:
      pid.15 = pid;
      if (pid.15 == 0) goto <D.7428>; else goto <D.7429>;
      <D.7428>:
      D.7430 = flags & 2;
      if (D.7430 == 0) goto <D.7431>; else goto <D.7432>;
      <D.7431>:
      pid.16 = fork ();
      pid = pid.16;
      <D.7432>:
      pid.15 = pid;
      if (pid.15 != 0) goto <D.7434>; else goto <D.7435>;
      <D.7434>:
      pid.15 = pid;
      D.7436 = pid.15 == -1;
      D.7437 = (int) D.7436;
      exit (D.7437);
      <D.7435>:
      {
        gint i;
        int fd;
        gchar * arg0;
        gchar * * actual_args;
        gint unused;

        D.7403 = info_pipe[0];
        close (D.7403);
        D.7424 = in_pipe[1];
        close (D.7424);
        D.7410 = out_pipe[0];
        close (D.7410);
        D.7417 = err_pipe[0];
        close (D.7417);
        D.7404 = info_pipe[1];
        fcntl (D.7404, 2, 1);
        D.7430 = flags & 2;
        if (D.7430 == 0) goto <D.7438>; else goto <D.7439>;
        <D.7438>:
        pid.17 = getpid ();
        pid = pid.17;
        <D.7176>:
        D.7404 = info_pipe[1];
        unused = write_all (D.7404, &pid, 4);
        if (unused == -1) goto <D.7441>; else goto <D.7177>;
        <D.7441>:
        D.7442 = __errno_location ();
        err.18 = *D.7442;
        if (err.18 == 4) goto <D.7176>; else goto <D.7177>;
        <D.7177>:
        <D.7439>:
        if (working_directory != 0B) goto <D.7444>; else goto <D.7445>;
        <D.7444>:
        D.7446 = chdir (working_directory);
        if (D.7446 == -1) goto <D.7447>; else goto <D.7448>;
        <D.7447>:
        {
          int err;

          try
            {
              D.7442 = __errno_location ();
              err.18 = *D.7442;
              err = err.18;
              <D.7179>:
              D.7404 = info_pipe[1];
              unused = write_all (D.7404, &err, 4);
              if (unused == -1) goto <D.7449>; else goto <D.7180>;
              <D.7449>:
              D.7442 = __errno_location ();
              err.18 = *D.7442;
              if (err.18 == 4) goto <D.7179>; else goto <D.7180>;
              <D.7180>:
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.7448>:
        <D.7445>:
        if (standard_output != 0B) goto <D.7450>; else goto <D.7451>;
        <D.7450>:
        D.7411 = out_pipe[1];
        dup2 (D.7411, 1);
        goto <D.7452>;
        <D.7451>:
        D.7453 = flags & 8;
        if (D.7453 != 0) goto <D.7454>; else goto <D.7455>;
        <D.7454>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 1);
        <D.7455>:
        <D.7452>:
        if (standard_error != 0B) goto <D.7456>; else goto <D.7457>;
        <D.7456>:
        D.7418 = err_pipe[1];
        dup2 (D.7418, 2);
        goto <D.7458>;
        <D.7457>:
        D.7459 = flags & 16;
        if (D.7459 != 0) goto <D.7460>; else goto <D.7461>;
        <D.7460>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 2);
        <D.7461>:
        <D.7458>:
        if (standard_input != 0B) goto <D.7462>; else goto <D.7463>;
        <D.7462>:
        D.7423 = in_pipe[0];
        dup2 (D.7423, 0);
        goto <D.7464>;
        <D.7463>:
        D.7465 = flags & 32;
        if (D.7465 == 0) goto <D.7466>; else goto <D.7467>;
        <D.7466>:
        fd = open ("/dev/null", 0);
        dup2 (fd, 0);
        <D.7467>:
        <D.7464>:
        D.7468 = flags & 1;
        if (D.7468 != 0) goto <D.7469>; else goto <D.7470>;
        <D.7469>:
        D.7471 = getdtablesize ();
        i = D.7471 + -1;
        goto <D.7182>;
        <D.7181>:
        close (i);
        i = i + -1;
        <D.7182>:
        if (i > 2) goto <D.7181>; else goto <D.7183>;
        <D.7183>:
        <D.7470>:
        D.7473 = flags & 64;
        if (D.7473 != 0) goto <D.7474>; else goto <D.7475>;
        <D.7474>:
        iftmp.19 = argv + 8;
        goto <D.7476>;
        <D.7475>:
        iftmp.19 = argv;
        <D.7476>:
        actual_args = iftmp.19;
        if (envp == 0B) goto <D.7477>; else goto <D.7478>;
        <D.7477>:
        envp = environ;
        <D.7478>:
        if (child_setup != 0B) goto <D.7479>; else goto <D.7480>;
        <D.7479>:
        child_setup (user_data);
        <D.7480>:
        arg0 = *argv;
        D.7483 = monoeg_g_path_is_absolute (arg0);
        if (D.7483 == 0) goto <D.7481>; else goto <D.7484>;
        <D.7484>:
        D.7485 = flags & 4;
        if (D.7485 != 0) goto <D.7481>; else goto <D.7482>;
        <D.7481>:
        D.7486 = *argv;
        arg0 = monoeg_g_find_program_in_path (D.7486);
        if (arg0 == 0B) goto <D.7487>; else goto <D.7488>;
        <D.7487>:
        {
          int err;

          try
            {
              err = 2;
              D.7404 = info_pipe[1];
              write_all (D.7404, &err, 4);
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.7488>:
        <D.7482>:
        execve (arg0, actual_args, envp);
        D.7404 = info_pipe[1];
        D.7442 = __errno_location ();
        write_all (D.7404, D.7442, 4);
        exit (0);
      }
      <D.7429>:
      D.7430 = flags & 2;
      if (D.7430 == 0) goto <D.7489>; else goto <D.7490>;
      <D.7489>:
      {
        int w;

        <D.7186>:
        pid.15 = pid;
        w = waitpid (pid.15, &status, 0);
        if (w == -1) goto <D.7491>; else goto <D.7187>;
        <D.7491>:
        D.7442 = __errno_location ();
        err.18 = *D.7442;
        if (err.18 == 4) goto <D.7186>; else goto <D.7187>;
        <D.7187>:
        status.20 = status;
        if (status.20 == 1) goto <D.7492>; else goto <D.7495>;
        <D.7495>:
        if (w == -1) goto <D.7492>; else goto <D.7493>;
        <D.7492>:
        D.7403 = info_pipe[0];
        close (D.7403);
        D.7404 = info_pipe[1];
        close (D.7404);
        D.7410 = out_pipe[0];
        close (D.7410);
        D.7411 = out_pipe[1];
        close (D.7411);
        D.7417 = err_pipe[0];
        close (D.7417);
        D.7418 = err_pipe[1];
        close (D.7418);
        D.7423 = in_pipe[0];
        close (D.7423);
        D.7424 = in_pipe[1];
        close (D.7424);
        if (error != 0B) goto <D.7496>; else goto <D.7497>;
        <D.7496>:
        status.20 = status;
        D.7498 = monoeg_g_error_new (0B, 1, "Error in fork (): %d", status.20);
        *error = D.7498;
        <D.7497>:
        D.7394 = 0;
        return D.7394;
        <D.7493>:
      }
      <D.7490>:
      D.7404 = info_pipe[1];
      close (D.7404);
      D.7423 = in_pipe[0];
      close (D.7423);
      D.7411 = out_pipe[1];
      close (D.7411);
      D.7418 = err_pipe[1];
      close (D.7418);
      D.7430 = flags & 2;
      if (D.7430 == 0) goto <D.7499>; else goto <D.7500>;
      <D.7499>:
      {
        int x;

        <D.7189>:
        D.7403 = info_pipe[0];
        D.7501 = read (D.7403, &pid, 4);
        x = (int) D.7501;
        if (x == -1) goto <D.7502>; else goto <D.7190>;
        <D.7502>:
        D.7442 = __errno_location ();
        err.18 = *D.7442;
        if (err.18 == 4) goto <D.7189>; else goto <D.7190>;
        <D.7190>:
      }
      <D.7500>:
      if (child_pid != 0B) goto <D.7503>; else goto <D.7504>;
      <D.7503>:
      pid.15 = pid;
      *child_pid = pid.15;
      <D.7504>:
      D.7403 = info_pipe[0];
      D.7505 = read (D.7403, &status, 4);
      if (D.7505 != 0) goto <D.7506>; else goto <D.7507>;
      <D.7506>:
      D.7403 = info_pipe[0];
      close (D.7403);
      D.7423 = in_pipe[0];
      close (D.7423);
      D.7411 = out_pipe[1];
      close (D.7411);
      D.7418 = err_pipe[1];
      close (D.7418);
      if (error != 0B) goto <D.7508>; else goto <D.7509>;
      <D.7508>:
      status.20 = status;
      status.20 = status;
      status.20 = status;
      D.7510 = strerror (status.20);
      D.7511 = monoeg_g_error_new (0B, status.20, "Error in exec (%d -> %s)", status.20, D.7510);
      *error = D.7511;
      <D.7509>:
      D.7394 = 0;
      return D.7394;
      <D.7507>:
      D.7403 = info_pipe[0];
      close (D.7403);
      if (standard_input != 0B) goto <D.7512>; else goto <D.7513>;
      <D.7512>:
      D.7424 = in_pipe[1];
      *standard_input = D.7424;
      <D.7513>:
      if (standard_output != 0B) goto <D.7514>; else goto <D.7515>;
      <D.7514>:
      D.7410 = out_pipe[0];
      *standard_output = D.7410;
      <D.7515>:
      if (standard_error != 0B) goto <D.7516>; else goto <D.7517>;
      <D.7516>:
      D.7417 = err_pipe[0];
      *standard_error = D.7417;
      <D.7517>:
      D.7394 = 1;
      return D.7394;
    }
  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.7520;
  int D.7523;
  int D.7528;
  int D.7530;
  int D.7531;
  int D.7534;
  int D.7535;

  D.7520 = __builtin_va_arg_pack_len ();
  if (D.7520 > 1) goto <D.7521>; else goto <D.7522>;
  <D.7521>:
  __open_too_many_args ();
  <D.7522>:
  D.7523 = __builtin_constant_p (__oflag);
  if (D.7523 != 0) goto <D.7524>; else goto <D.7525>;
  <D.7524>:
  D.7528 = __oflag & 64;
  if (D.7528 != 0) goto <D.7526>; else goto <D.7529>;
  <D.7529>:
  D.7530 = __oflag & 4259840;
  if (D.7530 == 4259840) goto <D.7526>; else goto <D.7527>;
  <D.7526>:
  D.7531 = __builtin_va_arg_pack_len ();
  if (D.7531 <= 0) goto <D.7532>; else goto <D.7533>;
  <D.7532>:
  __open_missing_mode ();
  D.7534 = __open_2 (__path, __oflag);
  return D.7534;
  <D.7533>:
  <D.7527>:
  D.7534 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7534;
  <D.7525>:
  D.7535 = __builtin_va_arg_pack_len ();
  if (D.7535 <= 0) goto <D.7536>; else goto <D.7537>;
  <D.7536>:
  D.7534 = __open_2 (__path, __oflag);
  return D.7534;
  <D.7537>:
  D.7534 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7534;
}


write_all (int fd, const void * vbuf, size_t n)
{
  const void * D.7539;
  long unsigned int D.7540;
  long int D.7541;
  int * D.7543;
  int D.7544;
  int D.7547;
  long unsigned int D.7548;
  const char * buf;
  size_t nwritten;
  int w;

  buf = vbuf;
  nwritten = 0;
  <D.7121>:
  <D.7119>:
  D.7539 = buf + nwritten;
  D.7540 = n - nwritten;
  D.7541 = write (fd, D.7539, D.7540);
  w = (int) D.7541;
  if (w == -1) goto <D.7542>; else goto <D.7120>;
  <D.7542>:
  D.7543 = __errno_location ();
  D.7544 = *D.7543;
  if (D.7544 == 4) goto <D.7119>; else goto <D.7120>;
  <D.7120>:
  if (w == -1) goto <D.7545>; else goto <D.7546>;
  <D.7545>:
  D.7547 = -1;
  return D.7547;
  <D.7546>:
  D.7548 = (long unsigned int) w;
  nwritten = D.7548 + nwritten;
  if (nwritten < n) goto <D.7121>; else goto <D.7122>;
  <D.7122>:
  D.7547 = (int) nwritten;
  return D.7547;
}