#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int execvp(char *, char **);
int /*<<< orphan*/ exit(int);
int fork();
int /*<<< orphan*/ printf(char *, ...);
char *strchr(char *, char);
int /*<<< orphan*/ strcpy(char *, char *);
char *strtok(char *, char *);
int wait(int /*<<< orphan*/ *);
void executeExternalCommand(char **givenData) {
  for (; 0;)
    printf("executeExternalCommand() called\n");
  int i = 0, j = 0;
  char tempData[100] = {0};
  char *dataHere = tempData;
  strcpy(tempData, givenData[0]);
  char *complexStringStart = strchr(tempData, '{');
  char *complexStringEnd = strchr(tempData, '}');
  if (complexStringStart != NULL && complexStringEnd != NULL) {
    if (complexStringStart < complexStringEnd) {
      complexStringStart++;
      dataHere = complexStringStart;
      *(complexStringEnd) = 0;
    }
  }
  for (; 0;)
    printf("Given : %s\n", dataHere);
  char *commandSplit[20] = {NULL};
  char *temp = strtok(dataHere, " ");
  int cmdChunks = 0;
  int z;
  for (z = 1; z < 8; z++) {
    while (temp != NULL) {
      commandSplit[cmdChunks++] = temp;
      temp = strtok(NULL, " ");
    }
    temp = givenData[z];
  }
  for (; 0;)
    printf("After TOK : %s, %s, %s, %s, %s\n", commandSplit[0], commandSplit[1],
           commandSplit[2], commandSplit[3], commandSplit[4]);
  i = fork();
  if (i == 0) {
    for (; 0;)
      printf("execvp(%s,double pointer to givenData)\n", givenData[0]);
    i = execvp(commandSplit[0], commandSplit);
    if (i == -1) {
      printf("%s failed to run\n", commandSplit[0]);
      exit(1);
    }
  } else {
    j = wait(NULL);
  }
}


x86 assembly (clang, -O0):
<executeExternalCommand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
xor    %eax,%eax
test   $0x1,%al
jne    11ae <executeExternalCommand+0x1e>
jmp    11c1 <executeExternalCommand+0x31>
lea    0xe4b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    119f <executeExternalCommand+0xf>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    (%rax),%rsi
call   1030 <strcpy@plt>
lea    -0x80(%rbp),%rdi
mov    $0x7b,%esi
call   1040 <strchr@plt>
mov    %rax,-0x90(%rbp)
lea    -0x80(%rbp),%rdi
mov    $0x7d,%esi
call   1040 <strchr@plt>
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x90(%rbp)
je     1283 <executeExternalCommand+0xf3>
cmpq   $0x0,-0x98(%rbp)
je     1283 <executeExternalCommand+0xf3>
mov    -0x90(%rbp),%rax
cmp    -0x98(%rbp),%rax
jae    127e <executeExternalCommand+0xee>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x98(%rbp),%rax
movb   $0x0,(%rax)
jmp    1283 <executeExternalCommand+0xf3>
jmp    1288 <executeExternalCommand+0xf8>
xor    %eax,%eax
test   $0x1,%al
jne    1297 <executeExternalCommand+0x107>
jmp    12b1 <executeExternalCommand+0x121>
mov    -0x88(%rbp),%rsi
lea    0xd7c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1288 <executeExternalCommand+0xf8>
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0xa0,%edx
call   1060 <memset@plt>
mov    -0x88(%rbp),%rdi
lea    0xd5b(%rip),%rsi
call   1070 <strtok@plt>
mov    %rax,-0x148(%rbp)
movl   $0x0,-0x14c(%rbp)
movl   $0x1,-0x150(%rbp)
cmpl   $0x8,-0x150(%rbp)
jge    137a <executeExternalCommand+0x1ea>
jmp    1304 <executeExternalCommand+0x174>
cmpq   $0x0,-0x148(%rbp)
je     1350 <executeExternalCommand+0x1c0>
mov    -0x148(%rbp),%rcx
mov    -0x14c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x14c(%rbp)
cltq
mov    %rcx,-0x140(%rbp,%rax,8)
ff
xor    %eax,%eax
mov    %eax,%edi
lea    0xcee(%rip),%rsi
call   1070 <strtok@plt>
mov    %rax,-0x148(%rbp)
jmp    1304 <executeExternalCommand+0x174>
mov    -0x8(%rbp),%rax
movslq -0x150(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x148(%rbp)
mov    -0x150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x150(%rbp)
jmp    12f2 <executeExternalCommand+0x162>
jmp    137f <executeExternalCommand+0x1ef>
xor    %eax,%eax
test   $0x1,%al
jne    138e <executeExternalCommand+0x1fe>
jmp    13c4 <executeExternalCommand+0x234>
mov    -0x140(%rbp),%rsi
mov    -0x138(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    -0x128(%rbp),%r8
mov    -0x120(%rbp),%r9
lea    0xc77(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    137f <executeExternalCommand+0x1ef>
mov    $0x0,%al
call   10b0 <fork@plt>
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    144a <executeExternalCommand+0x2ba>
jmp    13dd <executeExternalCommand+0x24d>
xor    %eax,%eax
test   $0x1,%al
jne    13ec <executeExternalCommand+0x25c>
jmp    1406 <executeExternalCommand+0x276>
mov    -0x8(%rbp),%rax
mov    (%rax),%rsi
lea    0xc55(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    13dd <executeExternalCommand+0x24d>
mov    -0x140(%rbp),%rdi
lea    -0x140(%rbp),%rsi
call   1080 <execvp@plt>
mov    %eax,-0xc(%rbp)
cmpl   $0xffffffff,-0xc(%rbp)
jne    1445 <executeExternalCommand+0x2b5>
mov    -0x140(%rbp),%rsi
lea    0xc43(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
jmp    1456 <executeExternalCommand+0x2c6>
xor    %eax,%eax
mov    %eax,%edi
call   10a0 <wait@plt>
mov    %eax,-0x10(%rbp)
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<executeExternalCommand>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdi,%r14
lea    0xa0(%rsp),%r15
xorps  %xmm0,%xmm0
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movl   $0x0,0x100(%rsp)
mov    (%rdi),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %r15,%rdi
mov    $0x7b,%esi
call   1040 <strchr@plt>
mov    %rax,%rbx
mov    %r15,%rdi
mov    $0x7d,%esi
call   1040 <strchr@plt>
test   %rbx,%rbx
je     121d <executeExternalCommand+0x9d>
test   %rax,%rax
je     121d <executeExternalCommand+0x9d>
cmp    %rax,%rbx
xorps  %xmm0,%xmm0
jae    1220 <executeExternalCommand+0xa0>
add    $0x1,%rbx
movb   $0x0,(%rax)
mov    %rbx,%r15
jmp    1220 <executeExternalCommand+0xa0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
lea    0xda2(%rip),%rsi
mov    %r15,%rdi
call   1060 <strtok@plt>
xor    %ebx,%ebx
test   %rax,%rax
je     1297 <executeExternalCommand+0x117>
lea    0xd8c(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,(%rsp,%rbx,8)
add    $0x1,%rbx
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
test   %rax,%rax
jne    1280 <executeExternalCommand+0x100>
mov    0x8(%r14),%rax
test   %rax,%rax
je     12ca <executeExternalCommand+0x14a>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%r12
lea    0xd52(%rip),%r15
xchg   %ax,%ax
mov    %rax,(%r12)
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
add    $0x8,%r12
add    $0x1,%ebx
test   %rax,%rax
jne    12b0 <executeExternalCommand+0x130>
mov    0x10(%r14),%rax
test   %rax,%rax
je     130a <executeExternalCommand+0x18a>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%r12
lea    0xd1f(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%r12)
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
add    $0x8,%r12
add    $0x1,%ebx
test   %rax,%rax
jne    12f0 <executeExternalCommand+0x170>
mov    0x18(%r14),%rax
test   %rax,%rax
je     134a <executeExternalCommand+0x1ca>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%r12
lea    0xcdf(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%r12)
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
add    $0x8,%r12
add    $0x1,%ebx
test   %rax,%rax
jne    1330 <executeExternalCommand+0x1b0>
mov    0x20(%r14),%rax
test   %rax,%rax
je     138a <executeExternalCommand+0x20a>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%r12
lea    0xc9f(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%r12)
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
add    $0x8,%r12
add    $0x1,%ebx
test   %rax,%rax
jne    1370 <executeExternalCommand+0x1f0>
mov    0x28(%r14),%rax
test   %rax,%rax
je     13ca <executeExternalCommand+0x24a>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%r12
lea    0xc5f(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%r12)
xor    %edi,%edi
mov    %r15,%rsi
call   1060 <strtok@plt>
add    $0x8,%r12
add    $0x1,%ebx
test   %rax,%rax
jne    13b0 <executeExternalCommand+0x230>
mov    0x30(%r14),%rax
test   %rax,%rax
je     1406 <executeExternalCommand+0x286>
movslq %ebx,%rcx
lea    (%rsp,%rcx,8),%rbx
lea    0xc1f(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%rbx)
xor    %edi,%edi
mov    %r14,%rsi
call   1060 <strtok@plt>
add    $0x8,%rbx
test   %rax,%rax
jne    13f0 <executeExternalCommand+0x270>
xor    %eax,%eax
call   10a0 <fork@plt>
test   %eax,%eax
je     141a <executeExternalCommand+0x29a>
xor    %edi,%edi
call   1090 <wait@plt>
jmp    142b <executeExternalCommand+0x2ab>
mov    (%rsp),%rdi
mov    %rsp,%rsi
call   1070 <execvp@plt>
cmp    $0xffffffff,%eax
je     143a <executeExternalCommand+0x2ba>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    (%rsp),%rsi
lea    0xbbd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@.str = [33 x i8] c"executeExternalCommand() called\0A\00"
@.str.1 = [12 x i8] c"Given : %s\0A\00"
@.str.2 = [2 x i8] c" \00"
@.str.3 = [32 x i8] c"After TOK : %s, %s, %s, %s, %s\0A\00"
@.str.4 = [40 x i8] c"execvp(%s,double pointer to givenData)\0A\00"
@.str.5 = [18 x i8] c"%s failed to run\0A\00"
define void @executeExternalCommand(i8** %0) {
%2 = alloca i8**
%3 = alloca i32
%4 = alloca i32
%5 = alloca [100 x i8]
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca [20 x i8*]
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
store i8** %0, i8*** %2
br label %13
13: ; preds = %14, %1
br i1 false, label %14, label %16
14: ; preds = %13
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
br label %13
16: ; preds = %13
store i32 0, i32* %3
store i32 0, i32* %4
%17 = bitcast [100 x i8]* %5 to i8*
%18 = getelementptr inbounds [100 x i8], [100 x i8]* %5, i64 0, i64 0
store i8* %18, i8** %6
%19 = getelementptr inbounds [100 x i8], [100 x i8]* %5, i64 0, i64 0
%20 = load i8**, i8*** %2
%21 = getelementptr inbounds i8*, i8** %20, i64 0
%22 = load i8*, i8** %21
%23 = call i32 @strcpy(i8* %19, i8* %22)
%24 = getelementptr inbounds [100 x i8], [100 x i8]* %5, i64 0, i64 0
%25 = call i8* @strchr(i8* %24, i8 signext 123)
store i8* %25, i8** %7
%26 = getelementptr inbounds [100 x i8], [100 x i8]* %5, i64 0, i64 0
%27 = call i8* @strchr(i8* %26, i8 signext 125)
store i8* %27, i8** %8
%28 = load i8*, i8** %7
%29 = icmp ne i8* %28, null
br i1 %29, label %30, label %43
30: ; preds = %16
%31 = load i8*, i8** %8
%32 = icmp ne i8* %31, null
br i1 %32, label %33, label %43
33: ; preds = %30
%34 = load i8*, i8** %7
%35 = load i8*, i8** %8
%36 = icmp ult i8* %34, %35
br i1 %36, label %37, label %42
37: ; preds = %33
%38 = load i8*, i8** %7
%39 = getelementptr inbounds i8, i8* %38, i32 1
store i8* %39, i8** %7
%40 = load i8*, i8** %7
store i8* %40, i8** %6
%41 = load i8*, i8** %8
store i8 0, i8* %41
br label %42
42: ; preds = %37, %33
br label %43
43: ; preds = %42, %30, %16
br label %44
44: ; preds = %45, %43
br i1 false, label %45, label %48
45: ; preds = %44
%46 = load i8*, i8** %6
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i8* %46)
br label %44
48: ; preds = %44
%49 = bitcast [20 x i8*]* %9 to i8*
%50 = load i8*, i8** %6
%51 = call i8* @strtok(i8* %50, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
store i8* %51, i8** %10
store i32 0, i32* %11
store i32 1, i32* %12
br label %52
52: ; preds = %72, %48
%53 = load i32, i32* %12
%54 = icmp slt i32 %53, 8
br i1 %54, label %55, label %75
55: ; preds = %52
br label %56
56: ; preds = %59, %55
%57 = load i8*, i8** %10
%58 = icmp ne i8* %57, null
br i1 %58, label %59, label %66
59: ; preds = %56
%60 = load i8*, i8** %10
%61 = load i32, i32* %11
%62 = add nsw i32 %61, 1
store i32 %62, i32* %11
%63 = sext i32 %61 to i64
%64 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 %63
store i8* %60, i8** %64
%65 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
store i8* %65, i8** %10
br label %56
66: ; preds = %56
%67 = load i8**, i8*** %2
%68 = load i32, i32* %12
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8*, i8** %67, i64 %69
%71 = load i8*, i8** %70
store i8* %71, i8** %10
br label %72
72: ; preds = %66
%73 = load i32, i32* %12
%74 = add nsw i32 %73, 1
store i32 %74, i32* %12
br label %52
75: ; preds = %52
br label %76
76: ; preds = %77, %75
br i1 false, label %77, label %89
77: ; preds = %76
%78 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 0
%79 = load i8*, i8** %78
%80 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 1
%81 = load i8*, i8** %80
%82 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 2
%83 = load i8*, i8** %82
%84 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 3
%85 = load i8*, i8** %84
%86 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 4
%87 = load i8*, i8** %86
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i8* %79, i8* %81, i8* %83, i8* %85, i8* %87)
br label %76
89: ; preds = %76
%90 = call i32 (...) @fork()
store i32 %90, i32* %3
%91 = load i32, i32* %3
%92 = icmp eq i32 %91, 0
br i1 %92, label %93, label %113
93: ; preds = %89
br label %94
94: ; preds = %95, %93
br i1 false, label %95, label %100
95: ; preds = %94
%96 = load i8**, i8*** %2
%97 = getelementptr inbounds i8*, i8** %96, i64 0
%98 = load i8*, i8** %97
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i8* %98)
br label %94
100: ; preds = %94
%101 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 0
%102 = load i8*, i8** %101
%103 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 0
%104 = call i32 @execvp(i8* %102, i8** %103)
store i32 %104, i32* %3
%105 = load i32, i32* %3
%106 = icmp eq i32 %105, -1
br i1 %106, label %107, label %112
107: ; preds = %100
%108 = getelementptr inbounds [20 x i8*], [20 x i8*]* %9, i64 0, i64 0
%109 = load i8*, i8** %108
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i8* %109)
%111 = call i32 @exit(i32 1)
unreachable
112: ; preds = %100
br label %115
113: ; preds = %89
%114 = call i32 @wait(i32* null)
store i32 %114, i32* %4
br label %115
115: ; preds = %113, %112
ret void
}

LLVM IR (-O2):
@.str.2 = [2 x i8] c" \00"
@.str.5 = [18 x i8] c"%s failed to run\0A\00"
define void @executeExternalCommand(i8** nocapture %0) {
%2 = alloca [100 x i8]
%3 = alloca [20 x i8*]
%4 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 0
%5 = load i8*, i8** %0
%6 = call i32 @strcpy(i8* %4, i8* %5)
%7 = call i8* @strchr(i8* %4, i8 signext 123)
%8 = call i8* @strchr(i8* %4, i8 signext 125)
%9 = icmp ne i8* %7, null
%10 = icmp ne i8* %8, null
%11 = select i1 %9, i1 %10, i1 false
%12 = icmp ult i8* %7, %8
%13 = select i1 %11, i1 %12, i1 false
br i1 %13, label %14, label %16
14: ; preds = %1
%15 = getelementptr inbounds i8, i8* %7, i64 1
store i8 0, i8* %8
br label %16
16: ; preds = %14, %1
%17 = phi i8* [ %15, %14 ], [ %4, %1 ]
%18 = bitcast [20 x i8*]* %3 to i8*
%19 = call i8* @strtok(i8* %17, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%20 = icmp eq i8* %19, null
br i1 %20, label %30, label %21
21: ; preds = %16, %21
%22 = phi i64 [ %24, %21 ], [ 0, %16 ]
%23 = phi i8* [ %26, %21 ], [ %19, %16 ]
%24 = add i64 %22, 1
%25 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %22
store i8* %23, i8** %25
%26 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%27 = icmp eq i8* %26, null
br i1 %27, label %28, label %21
28: ; preds = %21
%29 = trunc i64 %24 to i32
br label %30
30: ; preds = %28, %16
%31 = phi i32 [ 0, %16 ], [ %29, %28 ]
%32 = getelementptr inbounds i8*, i8** %0, i64 1
%33 = load i8*, i8** %32
%34 = icmp eq i8* %33, null
br i1 %34, label %46, label %35
35: ; preds = %30
%36 = sext i32 %31 to i64
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ %36, %35 ], [ %40, %37 ]
%39 = phi i8* [ %33, %35 ], [ %42, %37 ]
%40 = add i64 %38, 1
%41 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %38
store i8* %39, i8** %41
%42 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%43 = icmp eq i8* %42, null
br i1 %43, label %44, label %37
44: ; preds = %37
%45 = trunc i64 %40 to i32
br label %46
46: ; preds = %44, %30
%47 = phi i32 [ %31, %30 ], [ %45, %44 ]
%48 = getelementptr inbounds i8*, i8** %0, i64 2
%49 = load i8*, i8** %48
%50 = icmp eq i8* %49, null
br i1 %50, label %62, label %51
51: ; preds = %46
%52 = sext i32 %47 to i64
br label %53
53: ; preds = %53, %51
%54 = phi i64 [ %52, %51 ], [ %56, %53 ]
%55 = phi i8* [ %49, %51 ], [ %58, %53 ]
%56 = add i64 %54, 1
%57 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %54
store i8* %55, i8** %57
%58 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%59 = icmp eq i8* %58, null
br i1 %59, label %60, label %53
60: ; preds = %53
%61 = trunc i64 %56 to i32
br label %62
62: ; preds = %60, %46
%63 = phi i32 [ %47, %46 ], [ %61, %60 ]
%64 = getelementptr inbounds i8*, i8** %0, i64 3
%65 = load i8*, i8** %64
%66 = icmp eq i8* %65, null
br i1 %66, label %78, label %67
67: ; preds = %62
%68 = sext i32 %63 to i64
br label %69
69: ; preds = %69, %67
%70 = phi i64 [ %68, %67 ], [ %72, %69 ]
%71 = phi i8* [ %65, %67 ], [ %74, %69 ]
%72 = add i64 %70, 1
%73 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %70
store i8* %71, i8** %73
%74 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%75 = icmp eq i8* %74, null
br i1 %75, label %76, label %69
76: ; preds = %69
%77 = trunc i64 %72 to i32
br label %78
78: ; preds = %76, %62
%79 = phi i32 [ %63, %62 ], [ %77, %76 ]
%80 = getelementptr inbounds i8*, i8** %0, i64 4
%81 = load i8*, i8** %80
%82 = icmp eq i8* %81, null
br i1 %82, label %94, label %83
83: ; preds = %78
%84 = sext i32 %79 to i64
br label %85
85: ; preds = %85, %83
%86 = phi i64 [ %84, %83 ], [ %88, %85 ]
%87 = phi i8* [ %81, %83 ], [ %90, %85 ]
%88 = add i64 %86, 1
%89 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %86
store i8* %87, i8** %89
%90 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%91 = icmp eq i8* %90, null
br i1 %91, label %92, label %85
92: ; preds = %85
%93 = trunc i64 %88 to i32
br label %94
94: ; preds = %92, %78
%95 = phi i32 [ %79, %78 ], [ %93, %92 ]
%96 = getelementptr inbounds i8*, i8** %0, i64 5
%97 = load i8*, i8** %96
%98 = icmp eq i8* %97, null
br i1 %98, label %110, label %99
99: ; preds = %94
%100 = sext i32 %95 to i64
br label %101
101: ; preds = %101, %99
%102 = phi i64 [ %100, %99 ], [ %104, %101 ]
%103 = phi i8* [ %97, %99 ], [ %106, %101 ]
%104 = add i64 %102, 1
%105 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %102
store i8* %103, i8** %105
%106 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%107 = icmp eq i8* %106, null
br i1 %107, label %108, label %101
108: ; preds = %101
%109 = trunc i64 %104 to i32
br label %110
110: ; preds = %108, %94
%111 = phi i32 [ %95, %94 ], [ %109, %108 ]
%112 = getelementptr inbounds i8*, i8** %0, i64 6
%113 = load i8*, i8** %112
%114 = icmp eq i8* %113, null
br i1 %114, label %124, label %115
115: ; preds = %110
%116 = sext i32 %111 to i64
br label %117
117: ; preds = %117, %115
%118 = phi i64 [ %116, %115 ], [ %120, %117 ]
%119 = phi i8* [ %113, %115 ], [ %122, %117 ]
%120 = add i64 %118, 1
%121 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 %118
store i8* %119, i8** %121
%122 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%123 = icmp eq i8* %122, null
br i1 %123, label %124, label %117
124: ; preds = %117, %110
%125 = call i32 (...) @fork()
%126 = icmp eq i32 %125, 0
br i1 %126, label %127, label %136
127: ; preds = %124
%128 = getelementptr inbounds [20 x i8*], [20 x i8*]* %3, i64 0, i64 0
%129 = load i8*, i8** %128
%130 = call i32 @execvp(i8* %129, i8** %128)
%131 = icmp eq i32 %130, -1
br i1 %131, label %132, label %138
132: ; preds = %127
%133 = load i8*, i8** %128
%134 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i8* %133)
%135 = call i32 @exit(i32 1)
unreachable
136: ; preds = %124
%137 = call i32 @wait(i32* null)
br label %138
138: ; preds = %127, %136
ret void
}