#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 /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ parse(char *, char **);
int /*<<< orphan*/ run_process(char *, char **, int, char *, char *);
int /*<<< orphan*/ stderr;
int strlen(char *);
void parseAndExecCommandLine(char *command) {
  char *args[100];
  parse(command, args);
  char *inputFile = NULL;
  char *outputFile = NULL;
  int flags = 0;
  int len;
  for (len = 0; args[len]; len++)
    ;
  int i;
  for (i = 0; args[i]; i++) {
    if (args[i][0] == '<') {
      if (i + 1 <= len)
        inputFile = args[i + 1];
      else
        inputFile = NULL;
      flags |= 1;
      args[i] = NULL;
      i++;
    }
    if (!args[i]) {
      fprintf(stderr, "%s\n", "Syntax Error");
      return;
    }
    if (args[i][0] == '>') {
      flags |= 2;
      if (strlen(args[i]) == 2 && args[i][1] == '>') {
        flags |= 4;
        flags &= ~2;
      }
      if (i + 1 <= len)
        outputFile = args[i + 1];
      else
        outputFile = NULL;
      args[i] = NULL;
      i++;
    }
  }
  run_process(command, args, flags, inputFile, outputFile);
}


x86 assembly (clang, -O0):
<parseAndExecCommandLine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x350,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x330(%rbp),%rsi
call   1060 <parse@plt>
movq   $0x0,-0x338(%rbp)
movq   $0x0,-0x340(%rbp)
movl   $0x0,-0x344(%rbp)
movl   $0x0,-0x348(%rbp)
movslq -0x348(%rbp),%rax
cmpq   $0x0,-0x330(%rbp,%rax,8)
je     11b8 <parseAndExecCommandLine+0x78>
jmp    11a4 <parseAndExecCommandLine+0x64>
mov    -0x348(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x348(%rbp)
jmp    1189 <parseAndExecCommandLine+0x49>
movl   $0x0,-0x34c(%rbp)
movslq -0x34c(%rbp),%rax
cmpq   $0x0,-0x330(%rbp,%rax,8)
je     1395 <parseAndExecCommandLine+0x255>
movslq -0x34c(%rbp),%rax
mov    -0x330(%rbp,%rax,8),%rax
ff
movsbl (%rax),%eax
cmp    $0x3c,%eax
jne    1263 <parseAndExecCommandLine+0x123>
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
cmp    -0x348(%rbp),%eax
jg     1227 <parseAndExecCommandLine+0xe7>
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x330(%rbp,%rax,8),%rax
ff
mov    %rax,-0x338(%rbp)
jmp    1232 <parseAndExecCommandLine+0xf2>
movq   $0x0,-0x338(%rbp)
mov    -0x344(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x344(%rbp)
movslq -0x34c(%rbp),%rax
movq   $0x0,-0x330(%rbp,%rax,8)
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
movslq -0x34c(%rbp),%rax
cmpq   $0x0,-0x330(%rbp,%rax,8)
jne    129a <parseAndExecCommandLine+0x15a>
mov    0x2d60(%rip),%rax
mov    (%rax),%edi
lea    0xd77(%rip),%rsi
lea    0xd74(%rip),%rdx
call   1050 <fprintf@plt>
jmp    13b9 <parseAndExecCommandLine+0x279>
movslq -0x34c(%rbp),%rax
mov    -0x330(%rbp,%rax,8),%rax
ff
movsbl (%rax),%eax
cmp    $0x3e,%eax
jne    137c <parseAndExecCommandLine+0x23c>
mov    -0x344(%rbp),%eax
or     $0x2,%eax
mov    %eax,-0x344(%rbp)
movslq -0x34c(%rbp),%rax
mov    -0x330(%rbp,%rax,8),%rdi
ff
call   1040 <strlen@plt>
cmp    $0x2,%eax
jne    131b <parseAndExecCommandLine+0x1db>
movslq -0x34c(%rbp),%rax
mov    -0x330(%rbp,%rax,8),%rax
ff
movsbl 0x1(%rax),%eax
cmp    $0x3e,%eax
jne    131b <parseAndExecCommandLine+0x1db>
mov    -0x344(%rbp),%eax
or     $0x4,%eax
mov    %eax,-0x344(%rbp)
mov    -0x344(%rbp),%eax
and    $0xfffffffd,%eax
mov    %eax,-0x344(%rbp)
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
cmp    -0x348(%rbp),%eax
jg     134f <parseAndExecCommandLine+0x20f>
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x330(%rbp,%rax,8),%rax
ff
mov    %rax,-0x340(%rbp)
jmp    135a <parseAndExecCommandLine+0x21a>
movq   $0x0,-0x340(%rbp)
movslq -0x34c(%rbp),%rax
movq   $0x0,-0x330(%rbp,%rax,8)
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
jmp    1381 <parseAndExecCommandLine+0x241>
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
jmp    11c2 <parseAndExecCommandLine+0x82>
mov    -0x8(%rbp),%rdi
lea    -0x330(%rbp),%rsi
mov    -0x344(%rbp),%edx
mov    -0x338(%rbp),%rcx
mov    -0x340(%rbp),%r8
call   1030 <run_process@plt>
add    $0x350,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseAndExecCommandLine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x338,%rsp
mov    %rdi,%r14
lea    0x10(%rsp),%rbx
mov    %rbx,%rsi
call   1060 <parse@plt>
mov    $0xffffffff,%ebp
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ebp
cmpq   $0x0,(%rbx)
lea    0x8(%rbx),%rbx
jne    1170 <parseAndExecCommandLine+0x30>
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
mov    %r14,0x8(%rsp)
je     1274 <parseAndExecCommandLine+0x134>
xor    %eax,%eax
lea    0x10(%rsp),%rcx
xor    %r12d,%r12d
xor    %r8d,%r8d
xor    %r15d,%r15d
jmp    11d1 <parseAndExecCommandLine+0x91>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%r13d
mov    %ebx,%eax
movslq %eax,%rdx
add    $0x1,%eax
lea    (%rsp,%rdx,8),%rcx
add    $0x18,%rcx
mov    0x18(%rsp,%rdx,8),%rdx
test   %rdx,%rdx
je     127d <parseAndExecCommandLine+0x13d>
cmpb   $0x3c,(%rdx)
jne    11f0 <parseAndExecCommandLine+0xb0>
lea    0x1(%rax),%ebx
cmp    %ebp,%eax
jge    1200 <parseAndExecCommandLine+0xc0>
movslq %ebx,%rax
mov    0x10(%rsp,%rax,8),%r15
jmp    1203 <parseAndExecCommandLine+0xc3>
nopw   0x0(%rax,%rax,1)
mov    %eax,%ebx
jmp    120e <parseAndExecCommandLine+0xce>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %r15d,%r15d
or     $0x1,%r12d
movq   $0x0,(%rcx)
movslq %ebx,%r14
mov    0x10(%rsp,%r14,8),%rdi
test   %rdi,%rdi
je     1294 <parseAndExecCommandLine+0x154>
cmpb   $0x3e,(%rdi)
jne    11b0 <parseAndExecCommandLine+0x70>
mov    %r12d,%r13d
or     $0x2,%r13d
call   1040 <strlen@plt>
cmp    $0x2,%eax
jne    1247 <parseAndExecCommandLine+0x107>
mov    0x10(%rsp,%r14,8),%rax
cmpb   $0x3e,0x1(%rax)
jne    1247 <parseAndExecCommandLine+0x107>
and    $0xfffffff9,%r12d
or     $0x4,%r12d
mov    %r12d,%r13d
lea    0x1(%rbx),%eax
cmp    %ebp,%ebx
jge    1260 <parseAndExecCommandLine+0x120>
movslq %eax,%rcx
mov    0x10(%rsp,%rcx,8),%r8
jmp    1263 <parseAndExecCommandLine+0x123>
nopl   0x0(%rax,%rax,1)
xor    %r8d,%r8d
movq   $0x0,0x10(%rsp,%r14,8)
mov    %r13d,%r12d
jmp    11b5 <parseAndExecCommandLine+0x75>
xor    %r15d,%r15d
xor    %r8d,%r8d
xor    %r13d,%r13d
lea    0x10(%rsp),%rsi
mov    0x8(%rsp),%rdi
mov    %r13d,%edx
mov    %r15,%rcx
call   1030 <run_process@plt>
jmp    12b0 <parseAndExecCommandLine+0x170>
mov    0x2d45(%rip),%rax
mov    (%rax),%edi
lea    0xd5c(%rip),%rsi
lea    0xd59(%rip),%rdx
call   1050 <fprintf@plt>
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [13 x i8] c"Syntax Error\00"
define void @parseAndExecCommandLine(i8* %0) {
%2 = alloca i8*
%3 = alloca [100 x i8*]
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %2
%9 = load i8*, i8** %2
%10 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 0
%11 = call i32 @parse(i8* %9, i8** %10)
store i8* null, i8** %4
store i8* null, i8** %5
store i32 0, i32* %6
store i32 0, i32* %7
br label %12
12: ; preds = %19, %1
%13 = load i32, i32* %7
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %14
%16 = load i8*, i8** %15
%17 = icmp ne i8* %16, null
br i1 %17, label %18, label %22
18: ; preds = %12
br label %19
19: ; preds = %18
%20 = load i32, i32* %7
%21 = add nsw i32 %20, 1
store i32 %21, i32* %7
br label %12
22: ; preds = %12
store i32 0, i32* %8
br label %23
23: ; preds = %118, %22
%24 = load i32, i32* %8
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %25
%27 = load i8*, i8** %26
%28 = icmp ne i8* %27, null
br i1 %28, label %29, label %121
29: ; preds = %23
%30 = load i32, i32* %8
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %31
%33 = load i8*, i8** %32
%34 = getelementptr inbounds i8, i8* %33, i64 0
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = icmp eq i32 %36, 60
br i1 %37, label %38, label %58
38: ; preds = %29
%39 = load i32, i32* %8
%40 = add nsw i32 %39, 1
%41 = load i32, i32* %7
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %49
43: ; preds = %38
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %46
%48 = load i8*, i8** %47
store i8* %48, i8** %4
br label %50
49: ; preds = %38
store i8* null, i8** %4
br label %50
50: ; preds = %49, %43
%51 = load i32, i32* %6
%52 = or i32 %51, 1
store i32 %52, i32* %6
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %54
store i8* null, i8** %55
%56 = load i32, i32* %8
%57 = add nsw i32 %56, 1
store i32 %57, i32* %8
br label %58
58: ; preds = %50, %29
%59 = load i32, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %60
%62 = load i8*, i8** %61
%63 = icmp ne i8* %62, null
br i1 %63, label %67, label %64
64: ; preds = %58
%65 = load i32, i32* @stderr
%66 = call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
br label %128
67: ; preds = %58
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %69
%71 = load i8*, i8** %70
%72 = getelementptr inbounds i8, i8* %71, i64 0
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 62
br i1 %75, label %76, label %117
76: ; preds = %67
%77 = load i32, i32* %6
%78 = or i32 %77, 2
store i32 %78, i32* %6
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %80
%82 = load i8*, i8** %81
%83 = call i32 @strlen(i8* %82)
%84 = icmp eq i32 %83, 2
br i1 %84, label %85, label %99
85: ; preds = %76
%86 = load i32, i32* %8
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %87
%89 = load i8*, i8** %88
%90 = getelementptr inbounds i8, i8* %89, i64 1
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = icmp eq i32 %92, 62
br i1 %93, label %94, label %99
94: ; preds = %85
%95 = load i32, i32* %6
%96 = or i32 %95, 4
store i32 %96, i32* %6
%97 = load i32, i32* %6
%98 = and i32 %97, -3
store i32 %98, i32* %6
br label %99
99: ; preds = %94, %85, %76
%100 = load i32, i32* %8
%101 = add nsw i32 %100, 1
%102 = load i32, i32* %7
%103 = icmp sle i32 %101, %102
br i1 %103, label %104, label %110
104: ; preds = %99
%105 = load i32, i32* %8
%106 = add nsw i32 %105, 1
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %107
%109 = load i8*, i8** %108
store i8* %109, i8** %5
br label %111
110: ; preds = %99
store i8* null, i8** %5
br label %111
111: ; preds = %110, %104
%112 = load i32, i32* %8
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 %113
store i8* null, i8** %114
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 1
store i32 %116, i32* %8
br label %117
117: ; preds = %111, %67
br label %118
118: ; preds = %117
%119 = load i32, i32* %8
%120 = add nsw i32 %119, 1
store i32 %120, i32* %8
br label %23
121: ; preds = %23
%122 = load i8*, i8** %2
%123 = getelementptr inbounds [100 x i8*], [100 x i8*]* %3, i64 0, i64 0
%124 = load i32, i32* %6
%125 = load i8*, i8** %4
%126 = load i8*, i8** %5
%127 = call i32 @run_process(i8* %122, i8** %123, i32 %124, i8* %125, i8* %126)
br label %128
128: ; preds = %121, %64
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [13 x i8] c"Syntax Error\00"
define void @parseAndExecCommandLine(i8* %0) {
%2 = alloca [100 x i8*]
%3 = bitcast [100 x i8*]* %2 to i8*
%4 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 0
%5 = call i32 @parse(i8* %0, i8** %4)
br label %6
6: ; preds = %6, %1
%7 = phi i64 [ %11, %6 ], [ 0, %1 ]
%8 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 %7
%9 = load i8*, i8** %8
%10 = icmp eq i8* %9, null
%11 = add nuw i64 %7, 1
br i1 %10, label %12, label %6
12: ; preds = %6
%13 = trunc i64 %7 to i32
%14 = load i8*, i8** %4
%15 = icmp eq i8* %14, null
br i1 %15, label %80, label %16
16: ; preds = %12, %71
%17 = phi i8* [ %78, %71 ], [ %14, %12 ]
%18 = phi i8** [ %77, %71 ], [ %4, %12 ]
%19 = phi i32 [ %75, %71 ], [ 0, %12 ]
%20 = phi i32 [ %73, %71 ], [ 0, %12 ]
%21 = phi i8* [ %72, %71 ], [ null, %12 ]
%22 = phi i8* [ %36, %71 ], [ null, %12 ]
%23 = load i8, i8* %17
%24 = icmp eq i8 %23, 60
br i1 %24, label %25, label %35
25: ; preds = %16
%26 = add nsw i32 %19, 1
%27 = icmp slt i32 %19, %13
br i1 %27, label %28, label %32
28: ; preds = %25
%29 = sext i32 %26 to i64
%30 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 %29
%31 = load i8*, i8** %30
br label %32
32: ; preds = %25, %28
%33 = phi i8* [ %31, %28 ], [ null, %25 ]
%34 = or i32 %20, 1
store i8* null, i8** %18
br label %35
35: ; preds = %32, %16
%36 = phi i8* [ %33, %32 ], [ %22, %16 ]
%37 = phi i32 [ %34, %32 ], [ %20, %16 ]
%38 = phi i32 [ %26, %32 ], [ %19, %16 ]
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 %39
%41 = load i8*, i8** %40
%42 = icmp eq i8* %41, null
br i1 %42, label %43, label %46
43: ; preds = %35
%44 = load i32, i32* @stderr
%45 = call i32 @fprintf(i32 %44, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
br label %85
46: ; preds = %35
%47 = load i8, i8* %41
%48 = icmp eq i8 %47, 62
br i1 %48, label %49, label %71
49: ; preds = %46
%50 = or i32 %37, 2
%51 = call i32 @strlen(i8* %41)
%52 = icmp eq i32 %51, 2
br i1 %52, label %53, label %61
53: ; preds = %49
%54 = load i8*, i8** %40
%55 = getelementptr inbounds i8, i8* %54, i64 1
%56 = load i8, i8* %55
%57 = icmp eq i8 %56, 62
br i1 %57, label %58, label %61
58: ; preds = %53
%59 = and i32 %37, -7
%60 = or i32 %59, 4
br label %61
61: ; preds = %58, %53, %49
%62 = phi i32 [ %60, %58 ], [ %50, %53 ], [ %50, %49 ]
%63 = add nsw i32 %38, 1
%64 = icmp slt i32 %38, %13
br i1 %64, label %65, label %69
65: ; preds = %61
%66 = sext i32 %63 to i64
%67 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 %66
%68 = load i8*, i8** %67
br label %69
69: ; preds = %61, %65
%70 = phi i8* [ %68, %65 ], [ null, %61 ]
store i8* null, i8** %40
br label %71
71: ; preds = %46, %69
%72 = phi i8* [ %70, %69 ], [ %21, %46 ]
%73 = phi i32 [ %62, %69 ], [ %37, %46 ]
%74 = phi i32 [ %63, %69 ], [ %38, %46 ]
%75 = add nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [100 x i8*], [100 x i8*]* %2, i64 0, i64 %76
%78 = load i8*, i8** %77
%79 = icmp eq i8* %78, null
br i1 %79, label %80, label %16
80: ; preds = %71, %12
%81 = phi i8* [ null, %12 ], [ %36, %71 ]
%82 = phi i8* [ null, %12 ], [ %72, %71 ]
%83 = phi i32 [ 0, %12 ], [ %73, %71 ]
%84 = call i32 @run_process(i8* %0, i8** %4, i32 %83, i8* %81, i8* %82)
br label %85
85: ; preds = %80, %43
ret void
}