#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 */
scalar_t__ isspace(char);
unsigned int strlen(char *);
int parse(char *buffer, const char *list[3]) {
  unsigned len = strlen(buffer);
  int n = 0;
  char *s = buffer;
  while (len != 0 && isspace(buffer[len - 1]))
    buffer[--len] = 0;
  while (*s != 0 && isspace(*s))
    s++;
  if (*s != 0 && *s != '#') {
    while (n < 3) {
      if (*s == 0) {
        list[n++] = "";
      } else {
        list[n++] = s;
        while (*s != 0 && !isspace(*s))
          s++;
        if (isspace(*s)) {
          while (*s != 0 && isspace(*s))
            *s++ = 0;
        }
      }
    }
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<parse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x29(%rbp)
je     1179 <parse+0x59>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
test   $0x1,%al
jne    1189 <parse+0x69>
jmp    11a1 <parse+0x81>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
jmp    114b <parse+0x2b>
jmp    11a6 <parse+0x86>
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x2a(%rbp)
je     11d1 <parse+0xb1>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x2a(%rbp)
mov    -0x2a(%rbp),%al
test   $0x1,%al
jne    11e1 <parse+0xc1>
jmp    11f2 <parse+0xd2>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11a6 <parse+0x86>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1343 <parse+0x223>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     1343 <parse+0x223>
jmp    1217 <parse+0xf7>
cmpl   $0x3,-0x20(%rbp)
jge    1337 <parse+0x217>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1253 <parse+0x133>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
lea    0xdb6(%rip),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1332 <parse+0x212>
mov    -0x28(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x2b(%rbp)
je     129a <parse+0x17a>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x2b(%rbp)
mov    -0x2b(%rbp),%al
test   $0x1,%al
jne    12aa <parse+0x18a>
jmp    12bb <parse+0x19b>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    126d <parse+0x14d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
je     132d <parse+0x20d>
jmp    12d6 <parse+0x1b6>
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x2c(%rbp)
je     1301 <parse+0x1e1>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x2c(%rbp)
mov    -0x2c(%rbp),%al
test   $0x1,%al
jne    1311 <parse+0x1f1>
jmp    1328 <parse+0x208>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    12d6 <parse+0x1b6>
jmp    132d <parse+0x20d>
jmp    1332 <parse+0x212>
jmp    1217 <parse+0xf7>
movl   $0x1,-0x4(%rbp)
jmp    134a <parse+0x22a>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse>:
push   %rbp
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <strlen@plt>
test   %eax,%eax
je     115a <parse+0x3a>
mov    %eax,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsbl -0x1(%rbx,%rbp,1),%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     115a <parse+0x3a>
movb   $0x0,-0x1(%rbx,%rbp,1)
add    $0xffffffffffffffff,%rbp
jne    1140 <parse+0x20>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1189 <parse+0x69>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1190 <parse+0x70>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1170 <parse+0x50>
mov    %ebp,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret
mov    (%rbx),%al
test   %al,%al
je     1189 <parse+0x69>
cmp    $0x23,%al
je     1189 <parse+0x69>
mov    %rbx,(%r14)
mov    (%rbx),%al
test   %al,%al
je     11c9 <parse+0xa9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
jne    11cd <parse+0xad>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    11b0 <parse+0x90>
xor    %eax,%eax
jmp    11cf <parse+0xaf>
mov    (%rbx),%al
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1211 <parse+0xf1>
mov    (%rbx),%al
test   %al,%al
je     1244 <parse+0x124>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1211 <parse+0xf1>
lea    0x1(%rbx),%rcx
movb   $0x0,(%rbx)
movzbl 0x1(%rbx),%eax
mov    %rcx,%rbx
test   %al,%al
jne    11f0 <parse+0xd0>
jmp    1247 <parse+0x127>
cmpb   $0x0,(%rbx)
je     1244 <parse+0x124>
mov    %rbx,0x8(%r14)
mov    (%rbx),%al
test   %al,%al
je     123d <parse+0x11d>
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
jne    12e5 <parse+0x1c5>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1220 <parse+0x100>
xor    %eax,%eax
jmp    12e7 <parse+0x1c7>
mov    %rbx,%rcx
lea    0xdb2(%rip),%rax
mov    %rax,0x8(%r14)
mov    %rcx,%rbx
cmpb   $0x0,(%rbx)
je     1320 <parse+0x200>
mov    %rbx,0x10(%r14)
mov    (%rbx),%al
test   %al,%al
je     1289 <parse+0x169>
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
jne    128d <parse+0x16d>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1270 <parse+0x150>
xor    %eax,%eax
jmp    128f <parse+0x16f>
mov    (%rbx),%al
movsbl %al,%edi
call   1040 <isspace@plt>
mov    $0x1,%ebp
test   %rax,%rax
je     1189 <parse+0x69>
mov    (%rbx),%al
test   %al,%al
je     1189 <parse+0x69>
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1189 <parse+0x69>
movb   $0x0,-0x1(%rbx)
movzbl (%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    12c0 <parse+0x1a0>
jmp    1189 <parse+0x69>
mov    (%rbx),%al
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1255 <parse+0x135>
mov    (%rbx),%al
test   %al,%al
je     1320 <parse+0x200>
xchg   %ax,%ax
movsbl %al,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     1255 <parse+0x135>
movb   $0x0,(%rbx)
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1300 <parse+0x1e0>
lea    0xcd9(%rip),%rax
mov    %rax,0x10(%r14)
mov    $0x1,%ebp
jmp    1189 <parse+0x69>

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

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