monoeg_g_spawn_command_line_sync (const gchar * command_line, gchar * * standard_output, gchar * * standard_error, gint * exit_status, struct GError * * error)
{
  int D.8849;
  gboolean D.8852;
  int D.8855;
  int D.8860;
  int D.8865;
  int D.8866;
  int D.8873;
  int D.8874;
  int D.8875;
  gchar * * argv.0;
  gchar * D.8877;
  int D.8878;
  _Bool D.8887;
  _Bool D.8888;
  _Bool D.8889;
  int * D.8895;
  int D.8896;
  int status.1;
  int D.8898;
  int D.8903;
  int D.8904;
  pid_t pid;
  gchar * * argv;
  gint argc;
  int stdout_pipe[2];
  int stderr_pipe[2];
  int status;
  int res;

  try
    {
      stdout_pipe = *.LC0;
      stderr_pipe = *.LC0;
      D.8849 = monoeg_g_shell_parse_argv (command_line, &argc, &argv, error);
      if (D.8849 == 0) goto <D.8850>; else goto <D.8851>;
      <D.8850>:
      D.8852 = 0;
      return D.8852;
      <D.8851>:
      if (standard_output != 0B) goto <D.8853>; else goto <D.8854>;
      <D.8853>:
      D.8855 = create_pipe (&stdout_pipe, error);
      if (D.8855 == 0) goto <D.8856>; else goto <D.8857>;
      <D.8856>:
      D.8852 = 0;
      return D.8852;
      <D.8857>:
      <D.8854>:
      if (standard_error != 0B) goto <D.8858>; else goto <D.8859>;
      <D.8858>:
      D.8860 = create_pipe (&stderr_pipe, error);
      if (D.8860 == 0) goto <D.8861>; else goto <D.8862>;
      <D.8861>:
      if (standard_output != 0B) goto <D.8863>; else goto <D.8864>;
      <D.8863>:
      D.8865 = stdout_pipe[0];
      close (D.8865);
      D.8866 = stdout_pipe[1];
      close (D.8866);
      <D.8864>:
      D.8852 = 0;
      return D.8852;
      <D.8862>:
      <D.8859>:
      pid = fork ();
      if (pid == 0) goto <D.8867>; else goto <D.8868>;
      <D.8867>:
      {
        gint i;

        if (standard_output != 0B) goto <D.8869>; else goto <D.8870>;
        <D.8869>:
        D.8865 = stdout_pipe[0];
        close (D.8865);
        D.8866 = stdout_pipe[1];
        dup2 (D.8866, 1);
        <D.8870>:
        if (standard_error != 0B) goto <D.8871>; else goto <D.8872>;
        <D.8871>:
        D.8873 = stderr_pipe[0];
        close (D.8873);
        D.8874 = stderr_pipe[1];
        dup2 (D.8874, 2);
        <D.8872>:
        D.8875 = getdtablesize ();
        i = D.8875 + -1;
        goto <D.8801>;
        <D.8800>:
        close (i);
        i = i + -1;
        <D.8801>:
        if (i > 2) goto <D.8800>; else goto <D.8802>;
        <D.8802>:
        argv.0 = argv;
        D.8877 = *argv.0;
        D.8878 = monoeg_g_path_is_absolute (D.8877);
        if (D.8878 == 0) goto <D.8879>; else goto <D.8880>;
        <D.8879>:
        {
          gchar * arg0;

          argv.0 = argv;
          D.8877 = *argv.0;
          arg0 = monoeg_g_find_program_in_path (D.8877);
          if (arg0 == 0B) goto <D.8881>; else goto <D.8882>;
          <D.8881>:
          exit (1);
          <D.8882>:
          argv.0 = argv;
          *argv.0 = arg0;
        }
        <D.8880>:
        argv.0 = argv;
        D.8877 = *argv.0;
        argv.0 = argv;
        execv (D.8877, argv.0);
        exit (1);
      }
      <D.8868>:
      argv.0 = argv;
      monoeg_g_strfreev (argv.0);
      if (standard_output != 0B) goto <D.8883>; else goto <D.8884>;
      <D.8883>:
      D.8866 = stdout_pipe[1];
      close (D.8866);
      <D.8884>:
      if (standard_error != 0B) goto <D.8885>; else goto <D.8886>;
      <D.8885>:
      D.8874 = stderr_pipe[1];
      close (D.8874);
      <D.8886>:
      D.8887 = standard_output != 0B;
      D.8888 = standard_error != 0B;
      D.8889 = D.8887 | D.8888;
      if (D.8889 != 0) goto <D.8890>; else goto <D.8891>;
      <D.8890>:
      D.8865 = stdout_pipe[0];
      D.8873 = stderr_pipe[0];
      res = read_pipes (D.8865, standard_output, D.8873, standard_error, error);
      if (res != 0) goto <D.8892>; else goto <D.8893>;
      <D.8892>:
      waitpid (pid, &status, 1);
      D.8852 = 0;
      return D.8852;
      <D.8893>:
      <D.8891>:
      <D.8804>:
      res = waitpid (pid, &status, 0);
      if (res == -1) goto <D.8894>; else goto <D.8805>;
      <D.8894>:
      D.8895 = __errno_location ();
      D.8896 = *D.8895;
      if (D.8896 == 4) goto <D.8804>; else goto <D.8805>;
      <D.8805>:
      status.1 = status;
      D.8898 = status.1 & 127;
      if (D.8898 == 0) goto <D.8899>; else goto <D.8900>;
      <D.8899>:
      if (exit_status != 0B) goto <D.8901>; else goto <D.8902>;
      <D.8901>:
      status.1 = status;
      D.8903 = status.1 & 65280;
      D.8904 = D.8903 >> 8;
      *exit_status = D.8904;
      <D.8902>:
      <D.8900>:
      D.8852 = 1;
      return D.8852;
    }
  finally
    {
      argv = {CLOBBER};
      argc = {CLOBBER};
      stdout_pipe = {CLOBBER};
      stderr_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


create_pipe (int * fds, struct GError * * error)
{
  int D.8907;
  struct GError * D.8912;
  gboolean D.8913;

  D.8907 = pipe (fds);
  if (D.8907 == -1) goto <D.8908>; else goto <D.8909>;
  <D.8908>:
  if (error != 0B) goto <D.8910>; else goto <D.8911>;
  <D.8910>:
  D.8912 = monoeg_g_error_new (0B, 1, "%s", "Error creating pipe.");
  *error = D.8912;
  <D.8911>:
  D.8913 = 0;
  return D.8913;
  <D.8909>:
  D.8913 = 1;
  return D.8913;
}


read_pipes (int outfd, gchar * * out_str, int errfd, gchar * * err_str, struct GError * * error)
{
  _Bool D.8915;
  _Bool D.8916;
  _Bool D.8921;
  _Bool D.8922;
  _Bool D.8923;
  _Bool D.8925;
  _Bool D.8926;
  _Bool D.8927;
  long int D.8761;
  long int iftmp.2;
  int D.8931;
  long int iftmp.3;
  unsigned int __d.4;
  long int D.8940;
  long int D.8941;
  int D.8942;
  long unsigned int D.8943;
  long int D.8944;
  long int D.8945;
  _Bool D.8946;
  _Bool D.8947;
  _Bool D.8948;
  long int D.8763;
  long int iftmp.5;
  int D.8952;
  long int iftmp.6;
  unsigned int __d.7;
  long int D.8961;
  long int D.8962;
  int D.8963;
  long unsigned int D.8964;
  long int D.8965;
  long int D.8966;
  int D.8967;
  int D.8968;
  long int D.8765;
  long int iftmp.8;
  int D.8976;
  long int iftmp.9;
  unsigned int __d.10;
  long int D.8985;
  long int D.8986;
  int D.8991;
  long int D.8767;
  long int iftmp.11;
  int D.8997;
  long int iftmp.12;
  unsigned int __d.13;
  long int D.9006;
  long int D.9007;
  int * D.9016;
  int D.9017;
  gchar * D.9020;
  gchar * D.9023;
  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.8915 = outfd < 0;
      out_closed = (gboolean) D.8915;
      D.8916 = errfd < 0;
      err_closed = (gboolean) D.8916;
      if (out_str != 0B) goto <D.8917>; else goto <D.8918>;
      <D.8917>:
      *out_str = 0B;
      out = monoeg_g_string_new ("");
      <D.8918>:
      if (err_str != 0B) goto <D.8919>; else goto <D.8920>;
      <D.8919>:
      *err_str = 0B;
      err = monoeg_g_string_new ("");
      <D.8920>:
      <D.8768>:
      D.8921 = out_closed != 0;
      D.8922 = err_closed != 0;
      D.8923 = D.8921 & D.8922;
      if (D.8923 != 0) goto <D.8754>; else goto <D.8924>;
      <D.8924>:
      {
        unsigned int __i;
        struct fd_set * __arr;

        __arr = &rfds;
        __i = 0;
        goto <D.8758>;
        <D.8757>:
        __arr->fds_bits[__i] = 0;
        __i = __i + 1;
        <D.8758>:
        if (__i <= 31) goto <D.8757>; else goto <D.8759>;
        <D.8759>:
      }
      D.8925 = out_closed == 0;
      D.8926 = outfd >= 0;
      D.8927 = D.8925 & D.8926;
      if (D.8927 != 0) goto <D.8928>; else goto <D.8929>;
      <D.8928>:
      {
        long int __d;

        __d = outfd;
        D.8931 = __builtin_constant_p (__d);
        if (D.8931 != 0) goto <D.8932>; else goto <D.8933>;
        <D.8932>:
        __d.4 = (unsigned int) __d;
        if (__d.4 <= 1023) goto <D.8936>; else goto <D.8937>;
        <D.8936>:
        iftmp.3 = __d / 32;
        goto <D.8938>;
        <D.8937>:
        iftmp.3 = __fdelt_warn (__d);
        <D.8938>:
        iftmp.2 = iftmp.3;
        goto <D.8939>;
        <D.8933>:
        iftmp.2 = __fdelt_chk (__d);
        <D.8939>:
        D.8761 = iftmp.2;
      }
      D.8940 = D.8761;
      D.8941 = rfds.fds_bits[D.8940];
      D.8942 = outfd % 32;
      D.8943 = 1 << D.8942;
      D.8944 = (long int) D.8943;
      D.8945 = D.8941 | D.8944;
      rfds.fds_bits[D.8940] = D.8945;
      <D.8929>:
      D.8946 = err_closed == 0;
      D.8947 = errfd >= 0;
      D.8948 = D.8946 & D.8947;
      if (D.8948 != 0) goto <D.8949>; else goto <D.8950>;
      <D.8949>:
      {
        long int __d;

        __d = errfd;
        D.8952 = __builtin_constant_p (__d);
        if (D.8952 != 0) goto <D.8953>; else goto <D.8954>;
        <D.8953>:
        __d.7 = (unsigned int) __d;
        if (__d.7 <= 1023) goto <D.8957>; else goto <D.8958>;
        <D.8957>:
        iftmp.6 = __d / 32;
        goto <D.8959>;
        <D.8958>:
        iftmp.6 = __fdelt_warn (__d);
        <D.8959>:
        iftmp.5 = iftmp.6;
        goto <D.8960>;
        <D.8954>:
        iftmp.5 = __fdelt_chk (__d);
        <D.8960>:
        D.8763 = iftmp.5;
      }
      D.8961 = D.8763;
      D.8962 = rfds.fds_bits[D.8961];
      D.8963 = errfd % 32;
      D.8964 = 1 << D.8963;
      D.8965 = (long int) D.8964;
      D.8966 = D.8962 | D.8965;
      rfds.fds_bits[D.8961] = D.8966;
      <D.8950>:
      D.8967 = MAX_EXPR <errfd, outfd>;
      D.8968 = D.8967 + 1;
      res = select (D.8968, &rfds, 0B, 0B, 0B);
      if (res > 0) goto <D.8969>; else goto <D.8970>;
      <D.8969>:
      if (buffer == 0B) goto <D.8971>; else goto <D.8972>;
      <D.8971>:
      buffer = monoeg_malloc (1024);
      <D.8972>:
      if (out_closed == 0) goto <D.8973>; else goto <D.8974>;
      <D.8973>:
      {
        long int __d;

        __d = outfd;
        D.8976 = __builtin_constant_p (__d);
        if (D.8976 != 0) goto <D.8977>; else goto <D.8978>;
        <D.8977>:
        __d.10 = (unsigned int) __d;
        if (__d.10 <= 1023) goto <D.8981>; else goto <D.8982>;
        <D.8981>:
        iftmp.9 = __d / 32;
        goto <D.8983>;
        <D.8982>:
        iftmp.9 = __fdelt_warn (__d);
        <D.8983>:
        iftmp.8 = iftmp.9;
        goto <D.8984>;
        <D.8978>:
        iftmp.8 = __fdelt_chk (__d);
        <D.8984>:
        D.8765 = iftmp.8;
      }
      D.8985 = rfds.fds_bits[D.8765];
      D.8942 = outfd % 32;
      D.8943 = 1 << D.8942;
      D.8944 = (long int) D.8943;
      D.8986 = D.8985 & D.8944;
      if (D.8986 != 0) goto <D.8987>; else goto <D.8988>;
      <D.8987>:
      nread = safe_read (outfd, buffer, 1024, error);
      if (nread < 0) goto <D.8989>; else goto <D.8990>;
      <D.8989>:
      close (errfd);
      close (outfd);
      D.8991 = -1;
      return D.8991;
      <D.8990>:
      monoeg_g_string_append_len (out, buffer, nread);
      if (nread <= 0) goto <D.8992>; else goto <D.8993>;
      <D.8992>:
      out_closed = 1;
      close (outfd);
      <D.8993>:
      <D.8988>:
      <D.8974>:
      if (err_closed == 0) goto <D.8994>; else goto <D.8995>;
      <D.8994>:
      {
        long int __d;

        __d = errfd;
        D.8997 = __builtin_constant_p (__d);
        if (D.8997 != 0) goto <D.8998>; else goto <D.8999>;
        <D.8998>:
        __d.13 = (unsigned int) __d;
        if (__d.13 <= 1023) goto <D.9002>; else goto <D.9003>;
        <D.9002>:
        iftmp.12 = __d / 32;
        goto <D.9004>;
        <D.9003>:
        iftmp.12 = __fdelt_warn (__d);
        <D.9004>:
        iftmp.11 = iftmp.12;
        goto <D.9005>;
        <D.8999>:
        iftmp.11 = __fdelt_chk (__d);
        <D.9005>:
        D.8767 = iftmp.11;
      }
      D.9006 = rfds.fds_bits[D.8767];
      D.8963 = errfd % 32;
      D.8964 = 1 << D.8963;
      D.8965 = (long int) D.8964;
      D.9007 = D.9006 & D.8965;
      if (D.9007 != 0) goto <D.9008>; else goto <D.9009>;
      <D.9008>:
      nread = safe_read (errfd, buffer, 1024, error);
      if (nread < 0) goto <D.9010>; else goto <D.9011>;
      <D.9010>:
      close (errfd);
      close (outfd);
      D.8991 = -1;
      return D.8991;
      <D.9011>:
      monoeg_g_string_append_len (err, buffer, nread);
      if (nread <= 0) goto <D.9012>; else goto <D.9013>;
      <D.9012>:
      err_closed = 1;
      close (errfd);
      <D.9013>:
      <D.9009>:
      <D.8995>:
      <D.8970>:
      if (res > 0) goto <D.8768>; else goto <D.9014>;
      <D.9014>:
      if (res == -1) goto <D.9015>; else goto <D.8754>;
      <D.9015>:
      D.9016 = __errno_location ();
      D.9017 = *D.9016;
      if (D.9017 == 4) goto <D.8768>; else goto <D.8754>;
      <D.8754>:
      monoeg_g_free (buffer);
      if (out_str != 0B) goto <D.9018>; else goto <D.9019>;
      <D.9018>:
      D.9020 = monoeg_g_string_free (out, 0);
      *out_str = D.9020;
      <D.9019>:
      if (err_str != 0B) goto <D.9021>; else goto <D.9022>;
      <D.9021>:
      D.9023 = monoeg_g_string_free (err, 0);
      *err_str = D.9023;
      <D.9022>:
      D.8991 = 0;
      return D.8991;
    }
  finally
    {
      rfds = {CLOBBER};
    }
}


safe_read (int fd, gchar * buffer, gint count, struct GError * * error)
{
  unsigned int count.14;
  int * D.9028;
  int D.9029;
  _Bool D.9030;
  _Bool D.9031;
  _Bool D.9032;
  struct GError * D.9035;
  int D.9036;
  int res;

  <D.8737>:
  count.14 = (unsigned int) count;
  res = read (fd, buffer, count.14);
  if (res == -1) goto <D.9027>; else goto <D.8738>;
  <D.9027>:
  D.9028 = __errno_location ();
  D.9029 = *D.9028;
  if (D.9029 == 4) goto <D.8737>; else goto <D.8738>;
  <D.8738>:
  D.9030 = res == -1;
  D.9031 = error != 0B;
  D.9032 = D.9030 & D.9031;
  if (D.9032 != 0) goto <D.9033>; else goto <D.9034>;
  <D.9033>:
  D.9035 = monoeg_g_error_new (0B, 1, "%s", "Error reading from pipe.");
  *error = D.9035;
  <D.9034>:
  D.9036 = res;
  return D.9036;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.9038;
  int D.9041;
  ssize_t D.9044;
  unsigned int D.9045;
  unsigned int D.9046;
  unsigned int D.9049;

  D.9038 = __builtin_object_size (__buf, 0);
  if (D.9038 != 4294967295) goto <D.9039>; else goto <D.9040>;
  <D.9039>:
  D.9041 = __builtin_constant_p (__nbytes);
  if (D.9041 == 0) goto <D.9042>; else goto <D.9043>;
  <D.9042>:
  D.9045 = __builtin_object_size (__buf, 0);
  D.9044 = __read_chk (__fd, __buf, __nbytes, D.9045);
  return D.9044;
  <D.9043>:
  D.9046 = __builtin_object_size (__buf, 0);
  if (D.9046 < __nbytes) goto <D.9047>; else goto <D.9048>;
  <D.9047>:
  D.9049 = __builtin_object_size (__buf, 0);
  D.9044 = __read_chk_warn (__fd, __buf, __nbytes, D.9049);
  return D.9044;
  <D.9048>:
  <D.9040>:
  D.9044 = __read_alias (__fd, __buf, __nbytes);
  return D.9044;
}


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.9053;
  int D.9054;
  int D.9059;
  int D.9062;
  int D.9063;
  int D.9066;
  int D.9069;
  int D.9070;
  int D.9073;
  int D.9076;
  int D.9077;
  int pid.15;
  int pid.16;
  int D.9082;
  int D.9083;
  struct GError * D.9086;
  unsigned int D.9089;
  int pid.17;
  _Bool D.9095;
  int D.9096;
  int pid.18;
  int * D.9101;
  int err.19;
  int D.9105;
  unsigned int D.9112;
  unsigned int D.9118;
  unsigned int D.9124;
  unsigned int D.9127;
  int D.9130;
  gchar * * iftmp.20;
  unsigned int D.9132;
  int D.9142;
  unsigned int D.9144;
  gchar * D.9145;
  int status.21;
  struct GError * D.9157;
  int D.9163;
  char * D.9168;
  struct GError * D.9169;
  pid_t pid;
  int info_pipe[2];
  int in_pipe[2];
  int out_pipe[2];
  int err_pipe[2];
  int status;

  try
    {
      in_pipe = *.LC0;
      out_pipe = *.LC0;
      err_pipe = *.LC0;
      if (argv == 0B) goto <D.9051>; else goto <D.9052>;
      <D.9051>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gspawn.c", 324, "argv != NULL");
      D.9053 = 0;
      return D.9053;
      <D.9052>:
      D.9054 = create_pipe (&info_pipe, error);
      if (D.9054 == 0) goto <D.9055>; else goto <D.9056>;
      <D.9055>:
      D.9053 = 0;
      return D.9053;
      <D.9056>:
      if (standard_output != 0B) goto <D.9057>; else goto <D.9058>;
      <D.9057>:
      D.9059 = create_pipe (&out_pipe, error);
      if (D.9059 == 0) goto <D.9060>; else goto <D.9061>;
      <D.9060>:
      D.9062 = info_pipe[0];
      close (D.9062);
      D.9063 = info_pipe[1];
      close (D.9063);
      D.9053 = 0;
      return D.9053;
      <D.9061>:
      <D.9058>:
      if (standard_error != 0B) goto <D.9064>; else goto <D.9065>;
      <D.9064>:
      D.9066 = create_pipe (&err_pipe, error);
      if (D.9066 == 0) goto <D.9067>; else goto <D.9068>;
      <D.9067>:
      D.9062 = info_pipe[0];
      close (D.9062);
      D.9063 = info_pipe[1];
      close (D.9063);
      D.9069 = out_pipe[0];
      close (D.9069);
      D.9070 = out_pipe[1];
      close (D.9070);
      D.9053 = 0;
      return D.9053;
      <D.9068>:
      <D.9065>:
      if (standard_input != 0B) goto <D.9071>; else goto <D.9072>;
      <D.9071>:
      D.9073 = create_pipe (&in_pipe, error);
      if (D.9073 == 0) goto <D.9074>; else goto <D.9075>;
      <D.9074>:
      D.9062 = info_pipe[0];
      close (D.9062);
      D.9063 = info_pipe[1];
      close (D.9063);
      D.9069 = out_pipe[0];
      close (D.9069);
      D.9070 = out_pipe[1];
      close (D.9070);
      D.9076 = err_pipe[0];
      close (D.9076);
      D.9077 = err_pipe[1];
      close (D.9077);
      D.9053 = 0;
      return D.9053;
      <D.9075>:
      <D.9072>:
      pid.15 = fork ();
      pid = pid.15;
      pid.16 = pid;
      if (pid.16 == -1) goto <D.9080>; else goto <D.9081>;
      <D.9080>:
      D.9062 = info_pipe[0];
      close (D.9062);
      D.9063 = info_pipe[1];
      close (D.9063);
      D.9069 = out_pipe[0];
      close (D.9069);
      D.9070 = out_pipe[1];
      close (D.9070);
      D.9076 = err_pipe[0];
      close (D.9076);
      D.9077 = err_pipe[1];
      close (D.9077);
      D.9082 = in_pipe[0];
      close (D.9082);
      D.9083 = in_pipe[1];
      close (D.9083);
      if (error != 0B) goto <D.9084>; else goto <D.9085>;
      <D.9084>:
      D.9086 = monoeg_g_error_new (0B, 1, "%s", "Error in fork ()");
      *error = D.9086;
      <D.9085>:
      D.9053 = 0;
      return D.9053;
      <D.9081>:
      pid.16 = pid;
      if (pid.16 == 0) goto <D.9087>; else goto <D.9088>;
      <D.9087>:
      D.9089 = flags & 2;
      if (D.9089 == 0) goto <D.9090>; else goto <D.9091>;
      <D.9090>:
      pid.17 = fork ();
      pid = pid.17;
      <D.9091>:
      pid.16 = pid;
      if (pid.16 != 0) goto <D.9093>; else goto <D.9094>;
      <D.9093>:
      pid.16 = pid;
      D.9095 = pid.16 == -1;
      D.9096 = (int) D.9095;
      exit (D.9096);
      <D.9094>:
      {
        gint i;
        int fd;
        gchar * arg0;
        gchar * * actual_args;
        gint unused;

        D.9062 = info_pipe[0];
        close (D.9062);
        D.9083 = in_pipe[1];
        close (D.9083);
        D.9069 = out_pipe[0];
        close (D.9069);
        D.9076 = err_pipe[0];
        close (D.9076);
        D.9063 = info_pipe[1];
        fcntl (D.9063, 2, 1);
        D.9089 = flags & 2;
        if (D.9089 == 0) goto <D.9097>; else goto <D.9098>;
        <D.9097>:
        pid.18 = getpid ();
        pid = pid.18;
        <D.8830>:
        D.9063 = info_pipe[1];
        unused = write_all (D.9063, &pid, 4);
        if (unused == -1) goto <D.9100>; else goto <D.8831>;
        <D.9100>:
        D.9101 = __errno_location ();
        err.19 = *D.9101;
        if (err.19 == 4) goto <D.8830>; else goto <D.8831>;
        <D.8831>:
        <D.9098>:
        if (working_directory != 0B) goto <D.9103>; else goto <D.9104>;
        <D.9103>:
        D.9105 = chdir (working_directory);
        if (D.9105 == -1) goto <D.9106>; else goto <D.9107>;
        <D.9106>:
        {
          int err;

          try
            {
              D.9101 = __errno_location ();
              err.19 = *D.9101;
              err = err.19;
              <D.8833>:
              D.9063 = info_pipe[1];
              unused = write_all (D.9063, &err, 4);
              if (unused == -1) goto <D.9108>; else goto <D.8834>;
              <D.9108>:
              D.9101 = __errno_location ();
              err.19 = *D.9101;
              if (err.19 == 4) goto <D.8833>; else goto <D.8834>;
              <D.8834>:
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.9107>:
        <D.9104>:
        if (standard_output != 0B) goto <D.9109>; else goto <D.9110>;
        <D.9109>:
        D.9070 = out_pipe[1];
        dup2 (D.9070, 1);
        goto <D.9111>;
        <D.9110>:
        D.9112 = flags & 8;
        if (D.9112 != 0) goto <D.9113>; else goto <D.9114>;
        <D.9113>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 1);
        <D.9114>:
        <D.9111>:
        if (standard_error != 0B) goto <D.9115>; else goto <D.9116>;
        <D.9115>:
        D.9077 = err_pipe[1];
        dup2 (D.9077, 2);
        goto <D.9117>;
        <D.9116>:
        D.9118 = flags & 16;
        if (D.9118 != 0) goto <D.9119>; else goto <D.9120>;
        <D.9119>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 2);
        <D.9120>:
        <D.9117>:
        if (standard_input != 0B) goto <D.9121>; else goto <D.9122>;
        <D.9121>:
        D.9082 = in_pipe[0];
        dup2 (D.9082, 0);
        goto <D.9123>;
        <D.9122>:
        D.9124 = flags & 32;
        if (D.9124 == 0) goto <D.9125>; else goto <D.9126>;
        <D.9125>:
        fd = open ("/dev/null", 0);
        dup2 (fd, 0);
        <D.9126>:
        <D.9123>:
        D.9127 = flags & 1;
        if (D.9127 != 0) goto <D.9128>; else goto <D.9129>;
        <D.9128>:
        D.9130 = getdtablesize ();
        i = D.9130 + -1;
        goto <D.8836>;
        <D.8835>:
        close (i);
        i = i + -1;
        <D.8836>:
        if (i > 2) goto <D.8835>; else goto <D.8837>;
        <D.8837>:
        <D.9129>:
        D.9132 = flags & 64;
        if (D.9132 != 0) goto <D.9133>; else goto <D.9134>;
        <D.9133>:
        iftmp.20 = argv + 4;
        goto <D.9135>;
        <D.9134>:
        iftmp.20 = argv;
        <D.9135>:
        actual_args = iftmp.20;
        if (envp == 0B) goto <D.9136>; else goto <D.9137>;
        <D.9136>:
        envp = environ;
        <D.9137>:
        if (child_setup != 0B) goto <D.9138>; else goto <D.9139>;
        <D.9138>:
        child_setup (user_data);
        <D.9139>:
        arg0 = *argv;
        D.9142 = monoeg_g_path_is_absolute (arg0);
        if (D.9142 == 0) goto <D.9140>; else goto <D.9143>;
        <D.9143>:
        D.9144 = flags & 4;
        if (D.9144 != 0) goto <D.9140>; else goto <D.9141>;
        <D.9140>:
        D.9145 = *argv;
        arg0 = monoeg_g_find_program_in_path (D.9145);
        if (arg0 == 0B) goto <D.9146>; else goto <D.9147>;
        <D.9146>:
        {
          int err;

          try
            {
              err = 2;
              D.9063 = info_pipe[1];
              write_all (D.9063, &err, 4);
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.9147>:
        <D.9141>:
        execve (arg0, actual_args, envp);
        D.9063 = info_pipe[1];
        D.9101 = __errno_location ();
        write_all (D.9063, D.9101, 4);
        exit (0);
      }
      <D.9088>:
      D.9089 = flags & 2;
      if (D.9089 == 0) goto <D.9148>; else goto <D.9149>;
      <D.9148>:
      {
        int w;

        <D.8840>:
        pid.16 = pid;
        w = waitpid (pid.16, &status, 0);
        if (w == -1) goto <D.9150>; else goto <D.8841>;
        <D.9150>:
        D.9101 = __errno_location ();
        err.19 = *D.9101;
        if (err.19 == 4) goto <D.8840>; else goto <D.8841>;
        <D.8841>:
        status.21 = status;
        if (status.21 == 1) goto <D.9151>; else goto <D.9154>;
        <D.9154>:
        if (w == -1) goto <D.9151>; else goto <D.9152>;
        <D.9151>:
        D.9062 = info_pipe[0];
        close (D.9062);
        D.9063 = info_pipe[1];
        close (D.9063);
        D.9069 = out_pipe[0];
        close (D.9069);
        D.9070 = out_pipe[1];
        close (D.9070);
        D.9076 = err_pipe[0];
        close (D.9076);
        D.9077 = err_pipe[1];
        close (D.9077);
        D.9082 = in_pipe[0];
        close (D.9082);
        D.9083 = in_pipe[1];
        close (D.9083);
        if (error != 0B) goto <D.9155>; else goto <D.9156>;
        <D.9155>:
        status.21 = status;
        D.9157 = monoeg_g_error_new (0B, 1, "Error in fork (): %d", status.21);
        *error = D.9157;
        <D.9156>:
        D.9053 = 0;
        return D.9053;
        <D.9152>:
      }
      <D.9149>:
      D.9063 = info_pipe[1];
      close (D.9063);
      D.9082 = in_pipe[0];
      close (D.9082);
      D.9070 = out_pipe[1];
      close (D.9070);
      D.9077 = err_pipe[1];
      close (D.9077);
      D.9089 = flags & 2;
      if (D.9089 == 0) goto <D.9158>; else goto <D.9159>;
      <D.9158>:
      {
        int x;

        <D.8843>:
        D.9062 = info_pipe[0];
        x = read (D.9062, &pid, 4);
        if (x == -1) goto <D.9160>; else goto <D.8844>;
        <D.9160>:
        D.9101 = __errno_location ();
        err.19 = *D.9101;
        if (err.19 == 4) goto <D.8843>; else goto <D.8844>;
        <D.8844>:
      }
      <D.9159>:
      if (child_pid != 0B) goto <D.9161>; else goto <D.9162>;
      <D.9161>:
      pid.16 = pid;
      *child_pid = pid.16;
      <D.9162>:
      D.9062 = info_pipe[0];
      D.9163 = read (D.9062, &status, 4);
      if (D.9163 != 0) goto <D.9164>; else goto <D.9165>;
      <D.9164>:
      D.9062 = info_pipe[0];
      close (D.9062);
      D.9082 = in_pipe[0];
      close (D.9082);
      D.9070 = out_pipe[1];
      close (D.9070);
      D.9077 = err_pipe[1];
      close (D.9077);
      if (error != 0B) goto <D.9166>; else goto <D.9167>;
      <D.9166>:
      status.21 = status;
      status.21 = status;
      status.21 = status;
      D.9168 = strerror (status.21);
      D.9169 = monoeg_g_error_new (0B, status.21, "Error in exec (%d -> %s)", status.21, D.9168);
      *error = D.9169;
      <D.9167>:
      D.9053 = 0;
      return D.9053;
      <D.9165>:
      D.9062 = info_pipe[0];
      close (D.9062);
      if (standard_input != 0B) goto <D.9170>; else goto <D.9171>;
      <D.9170>:
      D.9083 = in_pipe[1];
      *standard_input = D.9083;
      <D.9171>:
      if (standard_output != 0B) goto <D.9172>; else goto <D.9173>;
      <D.9172>:
      D.9069 = out_pipe[0];
      *standard_output = D.9069;
      <D.9173>:
      if (standard_error != 0B) goto <D.9174>; else goto <D.9175>;
      <D.9174>:
      D.9076 = err_pipe[0];
      *standard_error = D.9076;
      <D.9175>:
      D.9053 = 1;
      return D.9053;
    }
  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.9178;
  int D.9181;
  int D.9186;
  int D.9188;
  int D.9189;
  int D.9192;
  int D.9193;

  D.9178 = __builtin_va_arg_pack_len ();
  if (D.9178 > 1) goto <D.9179>; else goto <D.9180>;
  <D.9179>:
  __open_too_many_args ();
  <D.9180>:
  D.9181 = __builtin_constant_p (__oflag);
  if (D.9181 != 0) goto <D.9182>; else goto <D.9183>;
  <D.9182>:
  D.9186 = __oflag & 64;
  if (D.9186 != 0) goto <D.9184>; else goto <D.9187>;
  <D.9187>:
  D.9188 = __oflag & 4210688;
  if (D.9188 == 4210688) goto <D.9184>; else goto <D.9185>;
  <D.9184>:
  D.9189 = __builtin_va_arg_pack_len ();
  if (D.9189 <= 0) goto <D.9190>; else goto <D.9191>;
  <D.9190>:
  __open_missing_mode ();
  D.9192 = __open_2 (__path, __oflag);
  return D.9192;
  <D.9191>:
  <D.9185>:
  D.9192 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9192;
  <D.9183>:
  D.9193 = __builtin_va_arg_pack_len ();
  if (D.9193 <= 0) goto <D.9194>; else goto <D.9195>;
  <D.9194>:
  D.9192 = __open_2 (__path, __oflag);
  return D.9192;
  <D.9195>:
  D.9192 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9192;
}


write_all (int fd, const void * vbuf, size_t n)
{
  const void * D.9197;
  unsigned int D.9198;
  int * D.9200;
  int D.9201;
  int D.9204;
  unsigned int w.22;
  const char * buf;
  size_t nwritten;
  int w;

  buf = vbuf;
  nwritten = 0;
  <D.8783>:
  <D.8781>:
  D.9197 = buf + nwritten;
  D.9198 = n - nwritten;
  w = write (fd, D.9197, D.9198);
  if (w == -1) goto <D.9199>; else goto <D.8782>;
  <D.9199>:
  D.9200 = __errno_location ();
  D.9201 = *D.9200;
  if (D.9201 == 4) goto <D.8781>; else goto <D.8782>;
  <D.8782>:
  if (w == -1) goto <D.9202>; else goto <D.9203>;
  <D.9202>:
  D.9204 = -1;
  return D.9204;
  <D.9203>:
  w.22 = (unsigned int) w;
  nwritten = nwritten + w.22;
  if (nwritten < n) goto <D.8783>; else goto <D.8784>;
  <D.8784>:
  D.9204 = (int) nwritten;
  return D.9204;
}