void write_command(int *w, char *argv[], char *string[]) {
    for (int r = 0; argv[r] != NULL; r++) {
        string[r] = strdup(argv[r]);
    }
}

void write_argument(int *argc, char *argv[], char *string[]) {
    int j = 0;
    for (j = 0; j < *argc; j++) {
        string[j] = strdup(argv[j]);
    }
}

static int runCmd(const char *cmd) {
    const char *cp;
    pid_t pid;
    int status;
    struct command structcommand[15];
    char **argv = 0;
    int argc = 1;
    bool pipe = false;
    char *string[z][z];
    char *pString3[40];
    char *pString2[40];
    int n = 0;
    char **ptr1;
    char string1[z];
    bool keep = false;
    char *pString1[z];
    char *pString[z];
    *pString1 = "";
    *pString = "";
    char *temp = {''};
    int w = 0;
    bool b = false;
    int j = 0;
    int i;
    int p = 0;
    char **ptr;
    char *tmpchar;
    char *cmdtmp;
    bool b1 = false;
    int y = 0;
    i = 0;
    int h = 0;
    nullterminate(string);
    if (cmd) {
        for (cp = cmd; *cp; cp++) {
            if ((*cp >= 'a') && (*cp <= 'z')) {
                continue;
            }
            if ((*cp >= 'A') && (*cp <= 'Z')) {
                continue;
            }
            if (isDecimal(*cp)) {
                continue;
            }
            if (isBlank(*cp)) {
                continue;
            }
            if ((*cp == '.') || (*cp == '/') || (*cp == '-') ||
                (*cp == '+') || (*cp == '=') || (*cp == '_') ||
                (*cp == ':') || (*cp == ',') || (*cp == ''') ||
                (*cp == '"')) {
                continue;
            }
        }
    }
    if (cmd) {
        cmdtmp = malloc(sizeof(char *) * strlen(cmd) + 1);
        strcpy(cmdtmp, cmd);
        tmpchar = malloc(sizeof(char *) * strlen(cmd) + 1);
        if (tmpchar == NULL) {
            printf("Error allocating memory!n"); /* print an error message */
            return 1; /* return with failure */
        }
        strcpy(tmpchar, cmd);
        ptr1 = str_split(pString3, cmdtmp, '|');
        if (strstr(cmd, "|") == NULL) {         /* not a pipeline */

            makeArgs(cmd, &argc, (const char ***) &argv, pipe, 0, 0);
            write_argument(&argc, argv, string[0]);
            n++;
        }
        else {
            for (i = 0; *(ptr1 + i); i++) { /* tokenize the input string for each pipeline*/
                n++; /* save number of pipelines */
                int e = 0; /* a counter */
                *pString = ""; /* should malloc and free this? */
                strcpy(string1, *(ptr1 + i));
                if ((string1[0] != '') && !isspace(string1[0])) { /* this is neither the end nor a new argument */
                    ptr = str_split(pString2, *(&string1), ' '); /* split the string at the arguments */
                    h = 0;
                    for (j = 0; *(ptr + j); j++) { /* step through the arguments */
                        /* the pipeline is in cmdtmp and the argument/program is in ptr[i] */
                        if (ptr + j && !b && strstr(*(ptr + j), "'")) {
                            b = true;
                            strcpy(temp, *(ptr + j));
                            if (y < 1) {
                                y++;
                            }
                        }
                        while (b) {
                            if (*(ptr + j) && strstr(*(ptr + j), "'")) { /* end of quote */
                                b = false;
                                if (y < 1) {
                                    string[i][j] = strcpy(temp, *(ptr + j));
                                }
                                y = 0;
                            }
                            else if (*(ptr + j)) { /* read until end of quote */
                                string[i][j] = temp;
                                continue;
                            } else {
                                b = false;
                                break;
                            }
                        }
                        if (ptr + j) {
                            if (*(ptr + j)[0] == '{') {
                                keep = true;
                            }
                            if (testFn(*(ptr + j))) { /* test for last char */
                                string[i][j - p] = concat(*pString1, *(ptr + j));
                                keep = false;
                                free(*pString1);
                                goto mylabel;
                            }
                            if (keep) {
                                *pString1 = concat(*pString1, *(ptr + j));
                                *pString1 = concat(*pString1, " ");
                                p++;
                            } else {
                                b1 = false;
                                int q = j;
                                for (e = 0; *(ptr + q + e); e++) { /* step through the string */
                                    b1 = true;
                                    if (*(ptr + e + q)) {
                                        *pString = concat(*pString, *(ptr + e + q));
                                        *pString = concat(*pString, " ");
                                    }
                                    j = e;
                                }
                                if (makeArgs(*pString, &argc, (const char ***) &argv, pipe, i, h)) {
                                    write_command(&w, argv, string[w]);
                                    w++;

                                } else {
                                    if (!b1) { /* no args (?) */
                                        for (int r = 0; argv[r] != NULL; r++) {
                                            string[i][r] = argv[r];
                                        }
                                    }
                                }
                            }
                        }
                    }
                    mylabel:
                    free(ptr);
                    dump_argv((const char *) "d", argc, argv);
                }
            }
            free(ptr1);
            free(cmdtmp);
            free(tmpchar);
        }
        for (i = 0; i < n; i++) {
            for (j = 0; DEBUG && string[i][j] != NULL; j++) {
                if (i == 0 && j == 0) printf("n");
                printf("p[%d][%d] %sn", i, j, string[i][j]);
            }
            structcommand[i].argv = string[i];
        }
        fflush(NULL);
        pid = fork();
        if (pid < 0) {
            perror("fork failed");
            return -1;
        }
        /* If we are the child process, then go execute the string.*/
        if (pid == 0) {
            /* spawn(cmd);*/
            fork_pipes(n, structcommand);
        }
        /*
         * We are the parent process.
         * Wait for the child to complete.
         */
        status = 0;
        while (((pid = waitpid(pid, &status, 0)) < 0) && (errno == EINTR));
        if (pid < 0) {
            fprintf(stderr, "Error from waitpid: %s", strerror(errno));
            return -1;
        }
        if (WIFSIGNALED(status)) {
            fprintf(stderr, "pid %ld: killed by signal %dn",
                    (long) pid, WTERMSIG(status));

            return -1;
        }
    }
    return WEXITSTATUS(status);


}