monoeg_g_spawn_command_line_sync (const gchar * command_line, gchar * * standard_output, gchar * * standard_error, gint * exit_status, struct GError * * error)
{
  int D.6655;
  gboolean D.6658;
  int D.6661;
  int D.6666;
  int D.6671;
  int D.6672;
  int D.6679;
  int D.6680;
  int D.6681;
  gchar * * argv.0;
  gchar * D.6683;
  int D.6684;
  _Bool D.6693;
  _Bool D.6694;
  _Bool D.6695;
  int * D.6701;
  int D.6702;
  union 
{
  int __in;
  int __i;
} D.6610;
  int status.1;
  int D.6704;
  int D.6705;
  union 
{
  int __in;
  int __i;
} D.6614;
  int D.6710;
  int D.6711;
  int D.6712;
  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.6655 = monoeg_g_shell_parse_argv (command_line, &argc, &argv, error);
      if (D.6655 == 0) goto <D.6656>; else goto <D.6657>;
      <D.6656>:
      D.6658 = 0;
      return D.6658;
      <D.6657>:
      if (standard_output != 0B) goto <D.6659>; else goto <D.6660>;
      <D.6659>:
      D.6661 = create_pipe (&stdout_pipe, error);
      if (D.6661 == 0) goto <D.6662>; else goto <D.6663>;
      <D.6662>:
      D.6658 = 0;
      return D.6658;
      <D.6663>:
      <D.6660>:
      if (standard_error != 0B) goto <D.6664>; else goto <D.6665>;
      <D.6664>:
      D.6666 = create_pipe (&stderr_pipe, error);
      if (D.6666 == 0) goto <D.6667>; else goto <D.6668>;
      <D.6667>:
      if (standard_output != 0B) goto <D.6669>; else goto <D.6670>;
      <D.6669>:
      D.6671 = stdout_pipe[0];
      close (D.6671);
      D.6672 = stdout_pipe[1];
      close (D.6672);
      <D.6670>:
      D.6658 = 0;
      return D.6658;
      <D.6668>:
      <D.6665>:
      pid = fork ();
      if (pid == 0) goto <D.6673>; else goto <D.6674>;
      <D.6673>:
      {
        gint i;

        if (standard_output != 0B) goto <D.6675>; else goto <D.6676>;
        <D.6675>:
        D.6671 = stdout_pipe[0];
        close (D.6671);
        D.6672 = stdout_pipe[1];
        dup2 (D.6672, 1);
        <D.6676>:
        if (standard_error != 0B) goto <D.6677>; else goto <D.6678>;
        <D.6677>:
        D.6679 = stderr_pipe[0];
        close (D.6679);
        D.6680 = stderr_pipe[1];
        dup2 (D.6680, 2);
        <D.6678>:
        D.6681 = getdtablesize ();
        i = D.6681 + -1;
        goto <D.6602>;
        <D.6601>:
        close (i);
        i = i + -1;
        <D.6602>:
        if (i > 2) goto <D.6601>; else goto <D.6603>;
        <D.6603>:
        argv.0 = argv;
        D.6683 = *argv.0;
        D.6684 = monoeg_g_path_is_absolute (D.6683);
        if (D.6684 == 0) goto <D.6685>; else goto <D.6686>;
        <D.6685>:
        {
          gchar * arg0;

          argv.0 = argv;
          D.6683 = *argv.0;
          arg0 = monoeg_g_find_program_in_path (D.6683);
          if (arg0 == 0B) goto <D.6687>; else goto <D.6688>;
          <D.6687>:
          exit (1);
          <D.6688>:
          argv.0 = argv;
          *argv.0 = arg0;
        }
        <D.6686>:
        argv.0 = argv;
        argv.0 = argv;
        D.6683 = *argv.0;
        execv (D.6683, argv.0);
        exit (1);
      }
      <D.6674>:
      argv.0 = argv;
      monoeg_g_strfreev (argv.0);
      if (standard_output != 0B) goto <D.6689>; else goto <D.6690>;
      <D.6689>:
      D.6672 = stdout_pipe[1];
      close (D.6672);
      <D.6690>:
      if (standard_error != 0B) goto <D.6691>; else goto <D.6692>;
      <D.6691>:
      D.6680 = stderr_pipe[1];
      close (D.6680);
      <D.6692>:
      D.6693 = standard_output != 0B;
      D.6694 = standard_error != 0B;
      D.6695 = D.6693 | D.6694;
      if (D.6695 != 0) goto <D.6696>; else goto <D.6697>;
      <D.6696>:
      D.6679 = stderr_pipe[0];
      D.6671 = stdout_pipe[0];
      res = read_pipes (D.6671, standard_output, D.6679, standard_error, error);
      if (res != 0) goto <D.6698>; else goto <D.6699>;
      <D.6698>:
      waitpid (pid, &status, 1);
      D.6658 = 0;
      return D.6658;
      <D.6699>:
      <D.6697>:
      <D.6605>:
      res = waitpid (pid, &status, 0);
      if (res == -1) goto <D.6700>; else goto <D.6606>;
      <D.6700>:
      D.6701 = __errno_location ();
      D.6702 = *D.6701;
      if (D.6702 == 4) goto <D.6605>; else goto <D.6606>;
      <D.6606>:
      status.1 = status;
      D.6610.__in = status.1;
      D.6704 = D.6610.__i;
      D.6705 = D.6704 & 127;
      if (D.6705 == 0) goto <D.6706>; else goto <D.6707>;
      <D.6706>:
      if (exit_status != 0B) goto <D.6708>; else goto <D.6709>;
      <D.6708>:
      {
        typedef union 
      {
        int __in;
        int __i;
      } unionunion 
      {
        int __in;
        int __i;
      };

        status.1 = status;
        D.6614.__in = status.1;
        D.6710 = D.6614.__i;
        D.6711 = D.6710 & 65280;
        D.6712 = D.6711 >> 8;
        *exit_status = D.6712;
      }
      <D.6709>:
      <D.6707>:
      D.6658 = 1;
      return D.6658;
    }
  finally
    {
      argv = {CLOBBER};
      argc = {CLOBBER};
      stdout_pipe = {CLOBBER};
      stderr_pipe = {CLOBBER};
      status = {CLOBBER};
    }
}


create_pipe (int * fds, struct GError * * error)
{
  int D.6715;
  struct GError * D.6720;
  gboolean D.6721;

  D.6715 = pipe (fds);
  if (D.6715 == -1) goto <D.6716>; else goto <D.6717>;
  <D.6716>:
  if (error != 0B) goto <D.6718>; else goto <D.6719>;
  <D.6718>:
  D.6720 = monoeg_g_error_new (0B, 1, "%s", "Error creating pipe.");
  *error = D.6720;
  <D.6719>:
  D.6721 = 0;
  return D.6721;
  <D.6717>:
  D.6721 = 1;
  return D.6721;
}


read_pipes (int outfd, gchar * * out_str, int errfd, gchar * * err_str, struct GError * * error)
{
  _Bool D.6723;
  _Bool D.6724;
  _Bool D.6729;
  _Bool D.6730;
  _Bool D.6731;
  _Bool D.6733;
  _Bool D.6734;
  _Bool D.6735;
  long int D.6562;
  long int iftmp.2;
  int D.6739;
  long int iftmp.3;
  unsigned long __d.4;
  long int D.6748;
  long int D.6749;
  int D.6750;
  long int D.6751;
  long int D.6752;
  _Bool D.6753;
  _Bool D.6754;
  _Bool D.6755;
  long int D.6564;
  long int iftmp.5;
  int D.6759;
  long int iftmp.6;
  unsigned long __d.7;
  long int D.6768;
  long int D.6769;
  int D.6770;
  long int D.6771;
  long int D.6772;
  int D.6773;
  int D.6774;
  long int D.6566;
  long int iftmp.8;
  int D.6782;
  long int iftmp.9;
  unsigned long __d.10;
  long int D.6791;
  long int D.6792;
  long int D.6793;
  int D.6798;
  long int D.6799;
  long int D.6568;
  long int iftmp.11;
  int D.6805;
  long int iftmp.12;
  unsigned long __d.13;
  long int D.6814;
  long int D.6815;
  long int D.6816;
  int * D.6825;
  int D.6826;
  gchar * D.6829;
  gchar * D.6832;
  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.6723 = outfd < 0;
      out_closed = (gboolean) D.6723;
      D.6724 = errfd < 0;
      err_closed = (gboolean) D.6724;
      if (out_str != 0B) goto <D.6725>; else goto <D.6726>;
      <D.6725>:
      *out_str = 0B;
      out = monoeg_g_string_new ("");
      <D.6726>:
      if (err_str != 0B) goto <D.6727>; else goto <D.6728>;
      <D.6727>:
      *err_str = 0B;
      err = monoeg_g_string_new ("");
      <D.6728>:
      <D.6569>:
      D.6729 = out_closed != 0;
      D.6730 = err_closed != 0;
      D.6731 = D.6729 & D.6730;
      if (D.6731 != 0) goto <D.6558>; else goto <D.6732>;
      <D.6732>:
      {
        int __d0;
        int __d1;

        __asm__ __volatile__("cld; rep; stosq" : "=c" __d0, "=D" __d1 : "a" 0, "0" 16, "1" &rfds.fds_bits[0] : "memory");
      }
      D.6733 = out_closed == 0;
      D.6734 = outfd >= 0;
      D.6735 = D.6733 & D.6734;
      if (D.6735 != 0) goto <D.6736>; else goto <D.6737>;
      <D.6736>:
      {
        long int __d;

        __d = (long int) outfd;
        D.6739 = __builtin_constant_p (__d);
        if (D.6739 != 0) goto <D.6740>; else goto <D.6741>;
        <D.6740>:
        __d.4 = (unsigned long) __d;
        if (__d.4 <= 1023) goto <D.6744>; else goto <D.6745>;
        <D.6744>:
        iftmp.3 = __d / 64;
        goto <D.6746>;
        <D.6745>:
        iftmp.3 = __fdelt_warn (__d);
        <D.6746>:
        iftmp.2 = iftmp.3;
        goto <D.6747>;
        <D.6741>:
        iftmp.2 = __fdelt_chk (__d);
        <D.6747>:
        D.6562 = iftmp.2;
      }
      D.6748 = D.6562;
      D.6749 = rfds.fds_bits[D.6748];
      D.6750 = outfd % 64;
      D.6751 = 1 << D.6750;
      D.6752 = D.6749 | D.6751;
      rfds.fds_bits[D.6748] = D.6752;
      <D.6737>:
      D.6753 = err_closed == 0;
      D.6754 = errfd >= 0;
      D.6755 = D.6753 & D.6754;
      if (D.6755 != 0) goto <D.6756>; else goto <D.6757>;
      <D.6756>:
      {
        long int __d;

        __d = (long int) errfd;
        D.6759 = __builtin_constant_p (__d);
        if (D.6759 != 0) goto <D.6760>; else goto <D.6761>;
        <D.6760>:
        __d.7 = (unsigned long) __d;
        if (__d.7 <= 1023) goto <D.6764>; else goto <D.6765>;
        <D.6764>:
        iftmp.6 = __d / 64;
        goto <D.6766>;
        <D.6765>:
        iftmp.6 = __fdelt_warn (__d);
        <D.6766>:
        iftmp.5 = iftmp.6;
        goto <D.6767>;
        <D.6761>:
        iftmp.5 = __fdelt_chk (__d);
        <D.6767>:
        D.6564 = iftmp.5;
      }
      D.6768 = D.6564;
      D.6769 = rfds.fds_bits[D.6768];
      D.6770 = errfd % 64;
      D.6771 = 1 << D.6770;
      D.6772 = D.6769 | D.6771;
      rfds.fds_bits[D.6768] = D.6772;
      <D.6757>:
      D.6773 = MAX_EXPR <errfd, outfd>;
      D.6774 = D.6773 + 1;
      res = select (D.6774, &rfds, 0B, 0B, 0B);
      if (res > 0) goto <D.6775>; else goto <D.6776>;
      <D.6775>:
      if (buffer == 0B) goto <D.6777>; else goto <D.6778>;
      <D.6777>:
      buffer = monoeg_malloc (1024);
      <D.6778>:
      if (out_closed == 0) goto <D.6779>; else goto <D.6780>;
      <D.6779>:
      {
        long int __d;

        __d = (long int) outfd;
        D.6782 = __builtin_constant_p (__d);
        if (D.6782 != 0) goto <D.6783>; else goto <D.6784>;
        <D.6783>:
        __d.10 = (unsigned long) __d;
        if (__d.10 <= 1023) goto <D.6787>; else goto <D.6788>;
        <D.6787>:
        iftmp.9 = __d / 64;
        goto <D.6789>;
        <D.6788>:
        iftmp.9 = __fdelt_warn (__d);
        <D.6789>:
        iftmp.8 = iftmp.9;
        goto <D.6790>;
        <D.6784>:
        iftmp.8 = __fdelt_chk (__d);
        <D.6790>:
        D.6566 = iftmp.8;
      }
      D.6791 = rfds.fds_bits[D.6566];
      D.6750 = outfd % 64;
      D.6792 = D.6791 >> D.6750;
      D.6793 = D.6792 & 1;
      if (D.6793 != 0) goto <D.6794>; else goto <D.6795>;
      <D.6794>:
      nread = safe_read (outfd, buffer, 1024, error);
      if (nread < 0) goto <D.6796>; else goto <D.6797>;
      <D.6796>:
      close (errfd);
      close (outfd);
      D.6798 = -1;
      return D.6798;
      <D.6797>:
      D.6799 = (long int) nread;
      monoeg_g_string_append_len (out, buffer, D.6799);
      if (nread <= 0) goto <D.6800>; else goto <D.6801>;
      <D.6800>:
      out_closed = 1;
      close (outfd);
      <D.6801>:
      <D.6795>:
      <D.6780>:
      if (err_closed == 0) goto <D.6802>; else goto <D.6803>;
      <D.6802>:
      {
        long int __d;

        __d = (long int) errfd;
        D.6805 = __builtin_constant_p (__d);
        if (D.6805 != 0) goto <D.6806>; else goto <D.6807>;
        <D.6806>:
        __d.13 = (unsigned long) __d;
        if (__d.13 <= 1023) goto <D.6810>; else goto <D.6811>;
        <D.6810>:
        iftmp.12 = __d / 64;
        goto <D.6812>;
        <D.6811>:
        iftmp.12 = __fdelt_warn (__d);
        <D.6812>:
        iftmp.11 = iftmp.12;
        goto <D.6813>;
        <D.6807>:
        iftmp.11 = __fdelt_chk (__d);
        <D.6813>:
        D.6568 = iftmp.11;
      }
      D.6814 = rfds.fds_bits[D.6568];
      D.6770 = errfd % 64;
      D.6815 = D.6814 >> D.6770;
      D.6816 = D.6815 & 1;
      if (D.6816 != 0) goto <D.6817>; else goto <D.6818>;
      <D.6817>:
      nread = safe_read (errfd, buffer, 1024, error);
      if (nread < 0) goto <D.6819>; else goto <D.6820>;
      <D.6819>:
      close (errfd);
      close (outfd);
      D.6798 = -1;
      return D.6798;
      <D.6820>:
      D.6799 = (long int) nread;
      monoeg_g_string_append_len (err, buffer, D.6799);
      if (nread <= 0) goto <D.6821>; else goto <D.6822>;
      <D.6821>:
      err_closed = 1;
      close (errfd);
      <D.6822>:
      <D.6818>:
      <D.6803>:
      <D.6776>:
      if (res > 0) goto <D.6569>; else goto <D.6823>;
      <D.6823>:
      if (res == -1) goto <D.6824>; else goto <D.6558>;
      <D.6824>:
      D.6825 = __errno_location ();
      D.6826 = *D.6825;
      if (D.6826 == 4) goto <D.6569>; else goto <D.6558>;
      <D.6558>:
      monoeg_g_free (buffer);
      if (out_str != 0B) goto <D.6827>; else goto <D.6828>;
      <D.6827>:
      D.6829 = monoeg_g_string_free (out, 0);
      *out_str = D.6829;
      <D.6828>:
      if (err_str != 0B) goto <D.6830>; else goto <D.6831>;
      <D.6830>:
      D.6832 = monoeg_g_string_free (err, 0);
      *err_str = D.6832;
      <D.6831>:
      D.6798 = 0;
      return D.6798;
    }
  finally
    {
      rfds = {CLOBBER};
    }
}


safe_read (int fd, gchar * buffer, gint count, struct GError * * error)
{
  long unsigned int D.6835;
  long int D.6836;
  int * D.6838;
  int D.6839;
  _Bool D.6840;
  _Bool D.6841;
  _Bool D.6842;
  struct GError * D.6845;
  int D.6846;
  int res;

  <D.6541>:
  D.6835 = (long unsigned int) count;
  D.6836 = read (fd, buffer, D.6835);
  res = (int) D.6836;
  if (res == -1) goto <D.6837>; else goto <D.6542>;
  <D.6837>:
  D.6838 = __errno_location ();
  D.6839 = *D.6838;
  if (D.6839 == 4) goto <D.6541>; else goto <D.6542>;
  <D.6542>:
  D.6840 = res == -1;
  D.6841 = error != 0B;
  D.6842 = D.6840 & D.6841;
  if (D.6842 != 0) goto <D.6843>; else goto <D.6844>;
  <D.6843>:
  D.6845 = monoeg_g_error_new (0B, 1, "%s", "Error reading from pipe.");
  *error = D.6845;
  <D.6844>:
  D.6846 = res;
  return D.6846;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.6848;
  int D.6851;
  ssize_t D.6854;
  long unsigned int D.6855;
  long unsigned int D.6856;
  long unsigned int D.6859;

  D.6848 = __builtin_object_size (__buf, 0);
  if (D.6848 != 18446744073709551615) goto <D.6849>; else goto <D.6850>;
  <D.6849>:
  D.6851 = __builtin_constant_p (__nbytes);
  if (D.6851 == 0) goto <D.6852>; else goto <D.6853>;
  <D.6852>:
  D.6855 = __builtin_object_size (__buf, 0);
  D.6854 = __read_chk (__fd, __buf, __nbytes, D.6855);
  return D.6854;
  <D.6853>:
  D.6856 = __builtin_object_size (__buf, 0);
  if (D.6856 < __nbytes) goto <D.6857>; else goto <D.6858>;
  <D.6857>:
  D.6859 = __builtin_object_size (__buf, 0);
  D.6854 = __read_chk_warn (__fd, __buf, __nbytes, D.6859);
  return D.6854;
  <D.6858>:
  <D.6850>:
  D.6854 = __read_alias (__fd, __buf, __nbytes);
  return D.6854;
}


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.6863;
  int D.6864;
  int D.6869;
  int D.6872;
  int D.6873;
  int D.6876;
  int D.6879;
  int D.6880;
  int D.6883;
  int D.6886;
  int D.6887;
  int pid.14;
  int pid.15;
  int D.6892;
  int D.6893;
  struct GError * D.6896;
  unsigned int D.6899;
  int pid.16;
  _Bool D.6905;
  int D.6906;
  int pid.17;
  int * D.6911;
  int err.18;
  int D.6915;
  unsigned int D.6922;
  unsigned int D.6928;
  unsigned int D.6934;
  unsigned int D.6937;
  int D.6940;
  gchar * * iftmp.19;
  unsigned int D.6942;
  int D.6952;
  unsigned int D.6954;
  gchar * D.6955;
  int status.20;
  struct GError * D.6967;
  long int D.6970;
  long int D.6974;
  char * D.6979;
  struct GError * D.6980;
  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.6861>; else goto <D.6862>;
      <D.6861>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gspawn.c", 324, "argv != NULL");
      D.6863 = 0;
      return D.6863;
      <D.6862>:
      D.6864 = create_pipe (&info_pipe, error);
      if (D.6864 == 0) goto <D.6865>; else goto <D.6866>;
      <D.6865>:
      D.6863 = 0;
      return D.6863;
      <D.6866>:
      if (standard_output != 0B) goto <D.6867>; else goto <D.6868>;
      <D.6867>:
      D.6869 = create_pipe (&out_pipe, error);
      if (D.6869 == 0) goto <D.6870>; else goto <D.6871>;
      <D.6870>:
      D.6872 = info_pipe[0];
      close (D.6872);
      D.6873 = info_pipe[1];
      close (D.6873);
      D.6863 = 0;
      return D.6863;
      <D.6871>:
      <D.6868>:
      if (standard_error != 0B) goto <D.6874>; else goto <D.6875>;
      <D.6874>:
      D.6876 = create_pipe (&err_pipe, error);
      if (D.6876 == 0) goto <D.6877>; else goto <D.6878>;
      <D.6877>:
      D.6872 = info_pipe[0];
      close (D.6872);
      D.6873 = info_pipe[1];
      close (D.6873);
      D.6879 = out_pipe[0];
      close (D.6879);
      D.6880 = out_pipe[1];
      close (D.6880);
      D.6863 = 0;
      return D.6863;
      <D.6878>:
      <D.6875>:
      if (standard_input != 0B) goto <D.6881>; else goto <D.6882>;
      <D.6881>:
      D.6883 = create_pipe (&in_pipe, error);
      if (D.6883 == 0) goto <D.6884>; else goto <D.6885>;
      <D.6884>:
      D.6872 = info_pipe[0];
      close (D.6872);
      D.6873 = info_pipe[1];
      close (D.6873);
      D.6879 = out_pipe[0];
      close (D.6879);
      D.6880 = out_pipe[1];
      close (D.6880);
      D.6886 = err_pipe[0];
      close (D.6886);
      D.6887 = err_pipe[1];
      close (D.6887);
      D.6863 = 0;
      return D.6863;
      <D.6885>:
      <D.6882>:
      pid.14 = fork ();
      pid = pid.14;
      pid.15 = pid;
      if (pid.15 == -1) goto <D.6890>; else goto <D.6891>;
      <D.6890>:
      D.6872 = info_pipe[0];
      close (D.6872);
      D.6873 = info_pipe[1];
      close (D.6873);
      D.6879 = out_pipe[0];
      close (D.6879);
      D.6880 = out_pipe[1];
      close (D.6880);
      D.6886 = err_pipe[0];
      close (D.6886);
      D.6887 = err_pipe[1];
      close (D.6887);
      D.6892 = in_pipe[0];
      close (D.6892);
      D.6893 = in_pipe[1];
      close (D.6893);
      if (error != 0B) goto <D.6894>; else goto <D.6895>;
      <D.6894>:
      D.6896 = monoeg_g_error_new (0B, 1, "%s", "Error in fork ()");
      *error = D.6896;
      <D.6895>:
      D.6863 = 0;
      return D.6863;
      <D.6891>:
      pid.15 = pid;
      if (pid.15 == 0) goto <D.6897>; else goto <D.6898>;
      <D.6897>:
      D.6899 = flags & 2;
      if (D.6899 == 0) goto <D.6900>; else goto <D.6901>;
      <D.6900>:
      pid.16 = fork ();
      pid = pid.16;
      <D.6901>:
      pid.15 = pid;
      if (pid.15 != 0) goto <D.6903>; else goto <D.6904>;
      <D.6903>:
      pid.15 = pid;
      D.6905 = pid.15 == -1;
      D.6906 = (int) D.6905;
      exit (D.6906);
      <D.6904>:
      {
        gint i;
        int fd;
        gchar * arg0;
        gchar * * actual_args;
        gint unused;

        D.6872 = info_pipe[0];
        close (D.6872);
        D.6893 = in_pipe[1];
        close (D.6893);
        D.6879 = out_pipe[0];
        close (D.6879);
        D.6886 = err_pipe[0];
        close (D.6886);
        D.6873 = info_pipe[1];
        fcntl (D.6873, 2, 1);
        D.6899 = flags & 2;
        if (D.6899 == 0) goto <D.6907>; else goto <D.6908>;
        <D.6907>:
        pid.17 = getpid ();
        pid = pid.17;
        <D.6639>:
        D.6873 = info_pipe[1];
        unused = write_all (D.6873, &pid, 4);
        if (unused == -1) goto <D.6910>; else goto <D.6640>;
        <D.6910>:
        D.6911 = __errno_location ();
        err.18 = *D.6911;
        if (err.18 == 4) goto <D.6639>; else goto <D.6640>;
        <D.6640>:
        <D.6908>:
        if (working_directory != 0B) goto <D.6913>; else goto <D.6914>;
        <D.6913>:
        D.6915 = chdir (working_directory);
        if (D.6915 == -1) goto <D.6916>; else goto <D.6917>;
        <D.6916>:
        {
          int err;

          try
            {
              D.6911 = __errno_location ();
              err.18 = *D.6911;
              err = err.18;
              <D.6642>:
              D.6873 = info_pipe[1];
              unused = write_all (D.6873, &err, 4);
              if (unused == -1) goto <D.6918>; else goto <D.6643>;
              <D.6918>:
              D.6911 = __errno_location ();
              err.18 = *D.6911;
              if (err.18 == 4) goto <D.6642>; else goto <D.6643>;
              <D.6643>:
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6917>:
        <D.6914>:
        if (standard_output != 0B) goto <D.6919>; else goto <D.6920>;
        <D.6919>:
        D.6880 = out_pipe[1];
        dup2 (D.6880, 1);
        goto <D.6921>;
        <D.6920>:
        D.6922 = flags & 8;
        if (D.6922 != 0) goto <D.6923>; else goto <D.6924>;
        <D.6923>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 1);
        <D.6924>:
        <D.6921>:
        if (standard_error != 0B) goto <D.6925>; else goto <D.6926>;
        <D.6925>:
        D.6887 = err_pipe[1];
        dup2 (D.6887, 2);
        goto <D.6927>;
        <D.6926>:
        D.6928 = flags & 16;
        if (D.6928 != 0) goto <D.6929>; else goto <D.6930>;
        <D.6929>:
        fd = open ("/dev/null", 1);
        dup2 (fd, 2);
        <D.6930>:
        <D.6927>:
        if (standard_input != 0B) goto <D.6931>; else goto <D.6932>;
        <D.6931>:
        D.6892 = in_pipe[0];
        dup2 (D.6892, 0);
        goto <D.6933>;
        <D.6932>:
        D.6934 = flags & 32;
        if (D.6934 == 0) goto <D.6935>; else goto <D.6936>;
        <D.6935>:
        fd = open ("/dev/null", 0);
        dup2 (fd, 0);
        <D.6936>:
        <D.6933>:
        D.6937 = flags & 1;
        if (D.6937 != 0) goto <D.6938>; else goto <D.6939>;
        <D.6938>:
        D.6940 = getdtablesize ();
        i = D.6940 + -1;
        goto <D.6645>;
        <D.6644>:
        close (i);
        i = i + -1;
        <D.6645>:
        if (i > 2) goto <D.6644>; else goto <D.6646>;
        <D.6646>:
        <D.6939>:
        D.6942 = flags & 64;
        if (D.6942 != 0) goto <D.6943>; else goto <D.6944>;
        <D.6943>:
        iftmp.19 = argv + 8;
        goto <D.6945>;
        <D.6944>:
        iftmp.19 = argv;
        <D.6945>:
        actual_args = iftmp.19;
        if (envp == 0B) goto <D.6946>; else goto <D.6947>;
        <D.6946>:
        envp = environ;
        <D.6947>:
        if (child_setup != 0B) goto <D.6948>; else goto <D.6949>;
        <D.6948>:
        child_setup (user_data);
        <D.6949>:
        arg0 = *argv;
        D.6952 = monoeg_g_path_is_absolute (arg0);
        if (D.6952 == 0) goto <D.6950>; else goto <D.6953>;
        <D.6953>:
        D.6954 = flags & 4;
        if (D.6954 != 0) goto <D.6950>; else goto <D.6951>;
        <D.6950>:
        D.6955 = *argv;
        arg0 = monoeg_g_find_program_in_path (D.6955);
        if (arg0 == 0B) goto <D.6956>; else goto <D.6957>;
        <D.6956>:
        {
          int err;

          try
            {
              err = 2;
              D.6873 = info_pipe[1];
              write_all (D.6873, &err, 4);
              exit (0);
            }
          finally
            {
              err = {CLOBBER};
            }
        }
        <D.6957>:
        <D.6951>:
        execve (arg0, actual_args, envp);
        D.6911 = __errno_location ();
        D.6873 = info_pipe[1];
        write_all (D.6873, D.6911, 4);
        exit (0);
      }
      <D.6898>:
      D.6899 = flags & 2;
      if (D.6899 == 0) goto <D.6958>; else goto <D.6959>;
      <D.6958>:
      {
        int w;

        <D.6649>:
        pid.15 = pid;
        w = waitpid (pid.15, &status, 0);
        if (w == -1) goto <D.6960>; else goto <D.6650>;
        <D.6960>:
        D.6911 = __errno_location ();
        err.18 = *D.6911;
        if (err.18 == 4) goto <D.6649>; else goto <D.6650>;
        <D.6650>:
        status.20 = status;
        if (status.20 == 1) goto <D.6961>; else goto <D.6964>;
        <D.6964>:
        if (w == -1) goto <D.6961>; else goto <D.6962>;
        <D.6961>:
        D.6872 = info_pipe[0];
        close (D.6872);
        D.6873 = info_pipe[1];
        close (D.6873);
        D.6879 = out_pipe[0];
        close (D.6879);
        D.6880 = out_pipe[1];
        close (D.6880);
        D.6886 = err_pipe[0];
        close (D.6886);
        D.6887 = err_pipe[1];
        close (D.6887);
        D.6892 = in_pipe[0];
        close (D.6892);
        D.6893 = in_pipe[1];
        close (D.6893);
        if (error != 0B) goto <D.6965>; else goto <D.6966>;
        <D.6965>:
        status.20 = status;
        D.6967 = monoeg_g_error_new (0B, 1, "Error in fork (): %d", status.20);
        *error = D.6967;
        <D.6966>:
        D.6863 = 0;
        return D.6863;
        <D.6962>:
      }
      <D.6959>:
      D.6873 = info_pipe[1];
      close (D.6873);
      D.6892 = in_pipe[0];
      close (D.6892);
      D.6880 = out_pipe[1];
      close (D.6880);
      D.6887 = err_pipe[1];
      close (D.6887);
      D.6899 = flags & 2;
      if (D.6899 == 0) goto <D.6968>; else goto <D.6969>;
      <D.6968>:
      {
        int x;

        <D.6652>:
        D.6872 = info_pipe[0];
        D.6970 = read (D.6872, &pid, 4);
        x = (int) D.6970;
        if (x == -1) goto <D.6971>; else goto <D.6653>;
        <D.6971>:
        D.6911 = __errno_location ();
        err.18 = *D.6911;
        if (err.18 == 4) goto <D.6652>; else goto <D.6653>;
        <D.6653>:
      }
      <D.6969>:
      if (child_pid != 0B) goto <D.6972>; else goto <D.6973>;
      <D.6972>:
      pid.15 = pid;
      *child_pid = pid.15;
      <D.6973>:
      D.6872 = info_pipe[0];
      D.6974 = read (D.6872, &status, 4);
      if (D.6974 != 0) goto <D.6975>; else goto <D.6976>;
      <D.6975>:
      D.6872 = info_pipe[0];
      close (D.6872);
      D.6892 = in_pipe[0];
      close (D.6892);
      D.6880 = out_pipe[1];
      close (D.6880);
      D.6887 = err_pipe[1];
      close (D.6887);
      if (error != 0B) goto <D.6977>; else goto <D.6978>;
      <D.6977>:
      status.20 = status;
      D.6979 = strerror (status.20);
      status.20 = status;
      status.20 = status;
      D.6980 = monoeg_g_error_new (0B, status.20, "Error in exec (%d -> %s)", status.20, D.6979);
      *error = D.6980;
      <D.6978>:
      D.6863 = 0;
      return D.6863;
      <D.6976>:
      D.6872 = info_pipe[0];
      close (D.6872);
      if (standard_input != 0B) goto <D.6981>; else goto <D.6982>;
      <D.6981>:
      D.6893 = in_pipe[1];
      *standard_input = D.6893;
      <D.6982>:
      if (standard_output != 0B) goto <D.6983>; else goto <D.6984>;
      <D.6983>:
      D.6879 = out_pipe[0];
      *standard_output = D.6879;
      <D.6984>:
      if (standard_error != 0B) goto <D.6985>; else goto <D.6986>;
      <D.6985>:
      D.6886 = err_pipe[0];
      *standard_error = D.6886;
      <D.6986>:
      D.6863 = 1;
      return D.6863;
    }
  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.6989;
  int D.6992;
  int D.6997;
  int D.6999;
  int D.7000;
  int D.7003;
  int D.7004;

  D.6989 = __builtin_va_arg_pack_len ();
  if (D.6989 > 1) goto <D.6990>; else goto <D.6991>;
  <D.6990>:
  __open_too_many_args ();
  <D.6991>:
  D.6992 = __builtin_constant_p (__oflag);
  if (D.6992 != 0) goto <D.6993>; else goto <D.6994>;
  <D.6993>:
  D.6997 = __oflag & 64;
  if (D.6997 != 0) goto <D.6995>; else goto <D.6998>;
  <D.6998>:
  D.6999 = __oflag & 4259840;
  if (D.6999 == 4259840) goto <D.6995>; else goto <D.6996>;
  <D.6995>:
  D.7000 = __builtin_va_arg_pack_len ();
  if (D.7000 <= 0) goto <D.7001>; else goto <D.7002>;
  <D.7001>:
  __open_missing_mode ();
  D.7003 = __open_2 (__path, __oflag);
  return D.7003;
  <D.7002>:
  <D.6996>:
  D.7003 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7003;
  <D.6994>:
  D.7004 = __builtin_va_arg_pack_len ();
  if (D.7004 <= 0) goto <D.7005>; else goto <D.7006>;
  <D.7005>:
  D.7003 = __open_2 (__path, __oflag);
  return D.7003;
  <D.7006>:
  D.7003 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7003;
}


write_all (int fd, const void * vbuf, size_t n)
{
  long unsigned int D.7008;
  const void * D.7009;
  long int D.7010;
  int * D.7012;
  int D.7013;
  int D.7016;
  long unsigned int D.7017;
  const char * buf;
  size_t nwritten;
  int w;

  buf = vbuf;
  nwritten = 0;
  <D.6584>:
  <D.6582>:
  D.7008 = n - nwritten;
  D.7009 = buf + nwritten;
  D.7010 = write (fd, D.7009, D.7008);
  w = (int) D.7010;
  if (w == -1) goto <D.7011>; else goto <D.6583>;
  <D.7011>:
  D.7012 = __errno_location ();
  D.7013 = *D.7012;
  if (D.7013 == 4) goto <D.6582>; else goto <D.6583>;
  <D.6583>:
  if (w == -1) goto <D.7014>; else goto <D.7015>;
  <D.7014>:
  D.7016 = -1;
  return D.7016;
  <D.7015>:
  D.7017 = (long unsigned int) w;
  nwritten = D.7017 + nwritten;
  if (nwritten < n) goto <D.6584>; else goto <D.6585>;
  <D.6585>:
  D.7016 = (int) nwritten;
  return D.7016;
}