#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);
int parse_zscore_line(char **start_ptr, char **qid_ptr, char **meas_ptr,
                      char **mean_ptr, char **stddev_ptr) {
  char *ptr = *start_ptr;
  while (*ptr != '\n' && isspace(*ptr))
    ptr++;
  *qid_ptr = ptr;
  while (!isspace(*ptr))
    ptr++;
  if (*ptr == '\n')
    return (-1);
  *ptr++ = '\0';
  while (*ptr != '\n' && isspace(*ptr))
    ptr++;
  *meas_ptr = ptr;
  while (!isspace(*ptr))
    ptr++;
  if (*ptr == '\n')
    return (-1);
  *ptr++ = '\0';
  while (*ptr != '\n' && isspace(*ptr))
    ptr++;
  *mean_ptr = ptr;
  while (!isspace(*ptr))
    ptr++;
  if (*ptr == '\n')
    return (-1);
  *ptr++ = '\0';
  while (*ptr != '\n' && isspace(*ptr))
    ptr++;
  if (*ptr == '\n')
    return (-1);
  *stddev_ptr = ptr;
  while (!isspace(*ptr))
    ptr++;
  if (*ptr != '\n') {
    *ptr++ = '\0';
    while (*ptr != '\n' && isspace(*ptr))
      ptr++;
    if (*ptr != '\n')
      return (-1);
  }
  *ptr++ = '\0';
  *start_ptr = ptr;
  return (0);
}


x86 assembly (clang, -O0):
<parse_zscore_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x39(%rbp)
je     1162 <parse_zscore_line+0x52>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1172 <parse_zscore_line+0x62>
jmp    1183 <parse_zscore_line+0x73>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1137 <parse_zscore_line+0x27>
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    11b0 <parse_zscore_line+0xa0>
jmp    11c1 <parse_zscore_line+0xb1>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    118e <parse_zscore_line+0x7e>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    11dd <parse_zscore_line+0xcd>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b8 <parse_zscore_line+0x3a8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3a(%rbp)
je     121a <parse_zscore_line+0x10a>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    122a <parse_zscore_line+0x11a>
jmp    123b <parse_zscore_line+0x12b>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11ef <parse_zscore_line+0xdf>
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1268 <parse_zscore_line+0x158>
jmp    1279 <parse_zscore_line+0x169>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1246 <parse_zscore_line+0x136>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1295 <parse_zscore_line+0x185>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b8 <parse_zscore_line+0x3a8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3b(%rbp)
je     12d2 <parse_zscore_line+0x1c2>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3b(%rbp)
mov    -0x3b(%rbp),%al
test   $0x1,%al
jne    12e2 <parse_zscore_line+0x1d2>
jmp    12f3 <parse_zscore_line+0x1e3>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12a7 <parse_zscore_line+0x197>
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1320 <parse_zscore_line+0x210>
jmp    1331 <parse_zscore_line+0x221>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12fe <parse_zscore_line+0x1ee>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    134d <parse_zscore_line+0x23d>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b8 <parse_zscore_line+0x3a8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3c(%rbp)
je     138a <parse_zscore_line+0x27a>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3c(%rbp)
mov    -0x3c(%rbp),%al
test   $0x1,%al
jne    139a <parse_zscore_line+0x28a>
jmp    13ab <parse_zscore_line+0x29b>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    135f <parse_zscore_line+0x24f>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    13c7 <parse_zscore_line+0x2b7>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b8 <parse_zscore_line+0x3a8>
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    13f4 <parse_zscore_line+0x2e4>
jmp    1405 <parse_zscore_line+0x2f5>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    13d2 <parse_zscore_line+0x2c2>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     1494 <parse_zscore_line+0x384>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3d(%rbp)
je     1452 <parse_zscore_line+0x342>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    1462 <parse_zscore_line+0x352>
jmp    1473 <parse_zscore_line+0x363>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1427 <parse_zscore_line+0x317>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     148f <parse_zscore_line+0x37f>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b8 <parse_zscore_line+0x3a8>
jmp    1494 <parse_zscore_line+0x384>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_zscore_line>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%rbp
mov    %rdi,%r14
mov    (%rdi),%rbx
mov    (%rbx),%al
cmp    $0xa,%al
mov    %r8,(%rsp)
je     1159 <parse_zscore_line+0x49>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl %al,%edi
call   1030 <isspace@plt>
test   %rax,%rax
je     1159 <parse_zscore_line+0x49>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmp    $0xa,%al
jne    1140 <parse_zscore_line+0x30>
mov    %rbx,0x0(%rbp)
nopl   (%rax)
movsbl (%rbx),%edi
call   1030 <isspace@plt>
add    $0x1,%rbx
test   %rax,%rax
je     1160 <parse_zscore_line+0x50>
mov    $0xffffffff,%r15d
cmpb   $0xa,-0x1(%rbx)
je     1217 <parse_zscore_line+0x107>
mov    %r14,%rbp
movb   $0x0,-0x1(%rbx)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%r14
movzbl (%rbx),%eax
cmp    $0xa,%al
je     11ab <parse_zscore_line+0x9b>
movsbl %al,%edi
call   1030 <isspace@plt>
lea    0x1(%r14),%rbx
test   %rax,%rax
jne    1190 <parse_zscore_line+0x80>
mov    %r14,0x0(%r13)
nop
movsbl (%r14),%edi
call   1030 <isspace@plt>
add    $0x1,%r14
test   %rax,%rax
je     11b0 <parse_zscore_line+0xa0>
cmpb   $0xa,-0x1(%r14)
je     1217 <parse_zscore_line+0x107>
movb   $0x0,-0x1(%r14)
xchg   %ax,%ax
mov    %r14,%rbx
movzbl (%r14),%eax
cmp    $0xa,%al
je     11ec <parse_zscore_line+0xdc>
movsbl %al,%edi
call   1030 <isspace@plt>
lea    0x1(%rbx),%r14
test   %rax,%rax
jne    11d0 <parse_zscore_line+0xc0>
mov    %rbx,(%r12)
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl 0x1(%rbx),%edi
add    $0x1,%rbx
call   1030 <isspace@plt>
test   %rax,%rax
je     1200 <parse_zscore_line+0xf0>
cmpb   $0xa,(%rbx)
jne    1229 <parse_zscore_line+0x119>
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbp,%r14
movb   $0x0,(%rbx)
nop
movzbl 0x1(%rbx),%eax
cmp    $0xa,%al
je     1217 <parse_zscore_line+0x107>
add    $0x1,%rbx
movsbl %al,%edi
call   1030 <isspace@plt>
test   %rax,%rax
jne    1230 <parse_zscore_line+0x120>
cmpb   $0xa,(%rbx)
je     1217 <parse_zscore_line+0x107>
mov    (%rsp),%rax
mov    %rbx,(%rax)
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%rbx),%edi
call   1030 <isspace@plt>
add    $0x1,%rbx
test   %rax,%rax
je     1260 <parse_zscore_line+0x150>
lea    -0x1(%rbx),%rbp
cmpb   $0xa,-0x1(%rbx)
je     12a5 <parse_zscore_line+0x195>
movb   $0x0,0x0(%rbp)
nop
mov    %rbx,%rbp
movzbl (%rbx),%eax
cmp    $0xa,%al
je     12a5 <parse_zscore_line+0x195>
movsbl %al,%edi
call   1030 <isspace@plt>
lea    0x1(%rbp),%rbx
test   %rax,%rax
jne    1280 <parse_zscore_line+0x170>
cmpb   $0xa,-0x1(%rbx)
jne    1217 <parse_zscore_line+0x107>
movb   $0x0,0x0(%rbp)
add    $0x1,%rbp
mov    %rbp,(%r14)
xor    %r15d,%r15d
jmp    1217 <parse_zscore_line+0x107>

LLVM IR (-O0):
define i32 @parse_zscore_line(i8** %0, i8** %1, i8** %2, i8** %3, i8** %4) {
%6 = alloca i32
%7 = alloca i8**
%8 = alloca i8**
%9 = alloca i8**
%10 = alloca i8**
%11 = alloca i8**
%12 = alloca i8*
store i8** %0, i8*** %7
store i8** %1, i8*** %8
store i8** %2, i8*** %9
store i8** %3, i8*** %10
store i8** %4, i8*** %11
%13 = load i8**, i8*** %7
%14 = load i8*, i8** %13
store i8* %14, i8** %12
br label %15
15: ; preds = %27, %5
%16 = load i8*, i8** %12
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = icmp ne i32 %18, 10
br i1 %19, label %20, label %25
20: ; preds = %15
%21 = load i8*, i8** %12
%22 = load i8, i8* %21
%23 = call i64 @isspace(i8 signext %22)
%24 = icmp ne i64 %23, 0
br label %25
25: ; preds = %20, %15
%26 = phi i1 [ false, %15 ], [ %24, %20 ]
br i1 %26, label %27, label %30
27: ; preds = %25
%28 = load i8*, i8** %12
%29 = getelementptr inbounds i8, i8* %28, i32 1
store i8* %29, i8** %12
br label %15
30: ; preds = %25
%31 = load i8*, i8** %12
%32 = load i8**, i8*** %8
store i8* %31, i8** %32
br label %33
33: ; preds = %39, %30
%34 = load i8*, i8** %12
%35 = load i8, i8* %34
%36 = call i64 @isspace(i8 signext %35)
%37 = icmp ne i64 %36, 0
%38 = xor i1 %37, true
br i1 %38, label %39, label %42
39: ; preds = %33
%40 = load i8*, i8** %12
%41 = getelementptr inbounds i8, i8* %40, i32 1
store i8* %41, i8** %12
br label %33
42: ; preds = %33
%43 = load i8*, i8** %12
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 10
br i1 %46, label %47, label %48
47: ; preds = %42
store i32 -1, i32* %6
br label %191
48: ; preds = %42
%49 = load i8*, i8** %12
%50 = getelementptr inbounds i8, i8* %49, i32 1
store i8* %50, i8** %12
store i8 0, i8* %49
br label %51
51: ; preds = %63, %48
%52 = load i8*, i8** %12
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = icmp ne i32 %54, 10
br i1 %55, label %56, label %61
56: ; preds = %51
%57 = load i8*, i8** %12
%58 = load i8, i8* %57
%59 = call i64 @isspace(i8 signext %58)
%60 = icmp ne i64 %59, 0
br label %61
61: ; preds = %56, %51
%62 = phi i1 [ false, %51 ], [ %60, %56 ]
br i1 %62, label %63, label %66
63: ; preds = %61
%64 = load i8*, i8** %12
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %12
br label %51
66: ; preds = %61
%67 = load i8*, i8** %12
%68 = load i8**, i8*** %9
store i8* %67, i8** %68
br label %69
69: ; preds = %75, %66
%70 = load i8*, i8** %12
%71 = load i8, i8* %70
%72 = call i64 @isspace(i8 signext %71)
%73 = icmp ne i64 %72, 0
%74 = xor i1 %73, true
br i1 %74, label %75, label %78
75: ; preds = %69
%76 = load i8*, i8** %12
%77 = getelementptr inbounds i8, i8* %76, i32 1
store i8* %77, i8** %12
br label %69
78: ; preds = %69
%79 = load i8*, i8** %12
%80 = load i8, i8* %79
%81 = sext i8 %80 to i32
%82 = icmp eq i32 %81, 10
br i1 %82, label %83, label %84
83: ; preds = %78
store i32 -1, i32* %6
br label %191
84: ; preds = %78
%85 = load i8*, i8** %12
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %12
store i8 0, i8* %85
br label %87
87: ; preds = %99, %84
%88 = load i8*, i8** %12
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = icmp ne i32 %90, 10
br i1 %91, label %92, label %97
92: ; preds = %87
%93 = load i8*, i8** %12
%94 = load i8, i8* %93
%95 = call i64 @isspace(i8 signext %94)
%96 = icmp ne i64 %95, 0
br label %97
97: ; preds = %92, %87
%98 = phi i1 [ false, %87 ], [ %96, %92 ]
br i1 %98, label %99, label %102
99: ; preds = %97
%100 = load i8*, i8** %12
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %12
br label %87
102: ; preds = %97
%103 = load i8*, i8** %12
%104 = load i8**, i8*** %10
store i8* %103, i8** %104
br label %105
105: ; preds = %111, %102
%106 = load i8*, i8** %12
%107 = load i8, i8* %106
%108 = call i64 @isspace(i8 signext %107)
%109 = icmp ne i64 %108, 0
%110 = xor i1 %109, true
br i1 %110, label %111, label %114
111: ; preds = %105
%112 = load i8*, i8** %12
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %12
br label %105
114: ; preds = %105
%115 = load i8*, i8** %12
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = icmp eq i32 %117, 10
br i1 %118, label %119, label %120
119: ; preds = %114
store i32 -1, i32* %6
br label %191
120: ; preds = %114
%121 = load i8*, i8** %12
%122 = getelementptr inbounds i8, i8* %121, i32 1
store i8* %122, i8** %12
store i8 0, i8* %121
br label %123
123: ; preds = %135, %120
%124 = load i8*, i8** %12
%125 = load i8, i8* %124
%126 = sext i8 %125 to i32
%127 = icmp ne i32 %126, 10
br i1 %127, label %128, label %133
128: ; preds = %123
%129 = load i8*, i8** %12
%130 = load i8, i8* %129
%131 = call i64 @isspace(i8 signext %130)
%132 = icmp ne i64 %131, 0
br label %133
133: ; preds = %128, %123
%134 = phi i1 [ false, %123 ], [ %132, %128 ]
br i1 %134, label %135, label %138
135: ; preds = %133
%136 = load i8*, i8** %12
%137 = getelementptr inbounds i8, i8* %136, i32 1
store i8* %137, i8** %12
br label %123
138: ; preds = %133
%139 = load i8*, i8** %12
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = icmp eq i32 %141, 10
br i1 %142, label %143, label %144
143: ; preds = %138
store i32 -1, i32* %6
br label %191
144: ; preds = %138
%145 = load i8*, i8** %12
%146 = load i8**, i8*** %11
store i8* %145, i8** %146
br label %147
147: ; preds = %153, %144
%148 = load i8*, i8** %12
%149 = load i8, i8* %148
%150 = call i64 @isspace(i8 signext %149)
%151 = icmp ne i64 %150, 0
%152 = xor i1 %151, true
br i1 %152, label %153, label %156
153: ; preds = %147
%154 = load i8*, i8** %12
%155 = getelementptr inbounds i8, i8* %154, i32 1
store i8* %155, i8** %12
br label %147
156: ; preds = %147
%157 = load i8*, i8** %12
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp ne i32 %159, 10
br i1 %160, label %161, label %186
161: ; preds = %156
%162 = load i8*, i8** %12
%163 = getelementptr inbounds i8, i8* %162, i32 1
store i8* %163, i8** %12
store i8 0, i8* %162
br label %164
164: ; preds = %176, %161
%165 = load i8*, i8** %12
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = icmp ne i32 %167, 10
br i1 %168, label %169, label %174
169: ; preds = %164
%170 = load i8*, i8** %12
%171 = load i8, i8* %170
%172 = call i64 @isspace(i8 signext %171)
%173 = icmp ne i64 %172, 0
br label %174
174: ; preds = %169, %164
%175 = phi i1 [ false, %164 ], [ %173, %169 ]
br i1 %175, label %176, label %179
176: ; preds = %174
%177 = load i8*, i8** %12
%178 = getelementptr inbounds i8, i8* %177, i32 1
store i8* %178, i8** %12
br label %164
179: ; preds = %174
%180 = load i8*, i8** %12
%181 = load i8, i8* %180
%182 = sext i8 %181 to i32
%183 = icmp ne i32 %182, 10
br i1 %183, label %184, label %185
184: ; preds = %179
store i32 -1, i32* %6
br label %191
185: ; preds = %179
br label %186
186: ; preds = %185, %156
%187 = load i8*, i8** %12
%188 = getelementptr inbounds i8, i8* %187, i32 1
store i8* %188, i8** %12
store i8 0, i8* %187
%189 = load i8*, i8** %12
%190 = load i8**, i8*** %7
store i8* %189, i8** %190
store i32 0, i32* %6
br label %191
191: ; preds = %186, %184, %143, %119, %83, %47
%192 = load i32, i32* %6
ret i32 %192
}

LLVM IR (-O2):
define i32 @parse_zscore_line(i8** nocapture %0, i8** nocapture writeonly %1, i8** nocapture writeonly %2, i8** nocapture writeonly %3, i8** nocapture writeonly %4) {
%6 = load i8*, i8** %0
%7 = load i8, i8* %6
%8 = icmp eq i8 %7, 10
br i1 %8, label %18, label %9
9: ; preds = %5, %14
%10 = phi i8 [ %16, %14 ], [ %7, %5 ]
%11 = phi i8* [ %15, %14 ], [ %6, %5 ]
%12 = tail call i64 @isspace(i8 signext %10)
%13 = icmp eq i64 %12, 0
br i1 %13, label %18, label %14
14: ; preds = %9
%15 = getelementptr inbounds i8, i8* %11, i64 1
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 10
br i1 %17, label %18, label %9
18: ; preds = %9, %14, %5
%19 = phi i8* [ %6, %5 ], [ %15, %14 ], [ %11, %9 ]
store i8* %19, i8** %1
br label %20
20: ; preds = %20, %18
%21 = phi i8* [ %19, %18 ], [ %25, %20 ]
%22 = load i8, i8* %21
%23 = tail call i64 @isspace(i8 signext %22)
%24 = icmp eq i64 %23, 0
%25 = getelementptr inbounds i8, i8* %21, i64 1
br i1 %24, label %20, label %26
26: ; preds = %20
%27 = load i8, i8* %21
%28 = icmp eq i8 %27, 10
br i1 %28, label %104, label %29
29: ; preds = %26
store i8 0, i8* %21
br label %30
30: ; preds = %35, %29
%31 = phi i8* [ %21, %29 ], [ %32, %35 ]
%32 = getelementptr inbounds i8, i8* %31, i64 1
%33 = load i8, i8* %32
%34 = icmp eq i8 %33, 10
br i1 %34, label %38, label %35
35: ; preds = %30
%36 = tail call i64 @isspace(i8 signext %33)
%37 = icmp eq i64 %36, 0
br i1 %37, label %38, label %30
38: ; preds = %30, %35
store i8* %32, i8** %2
br label %39
39: ; preds = %39, %38
%40 = phi i8* [ %32, %38 ], [ %44, %39 ]
%41 = load i8, i8* %40
%42 = tail call i64 @isspace(i8 signext %41)
%43 = icmp eq i64 %42, 0
%44 = getelementptr inbounds i8, i8* %40, i64 1
br i1 %43, label %39, label %45
45: ; preds = %39
%46 = load i8, i8* %40
%47 = icmp eq i8 %46, 10
br i1 %47, label %104, label %48
48: ; preds = %45
store i8 0, i8* %40
br label %49
49: ; preds = %54, %48
%50 = phi i8* [ %40, %48 ], [ %51, %54 ]
%51 = getelementptr inbounds i8, i8* %50, i64 1
%52 = load i8, i8* %51
%53 = icmp eq i8 %52, 10
br i1 %53, label %57, label %54
54: ; preds = %49
%55 = tail call i64 @isspace(i8 signext %52)
%56 = icmp eq i64 %55, 0
br i1 %56, label %57, label %49
57: ; preds = %49, %54
store i8* %51, i8** %3
br label %58
58: ; preds = %58, %57
%59 = phi i8* [ %51, %57 ], [ %63, %58 ]
%60 = load i8, i8* %59
%61 = tail call i64 @isspace(i8 signext %60)
%62 = icmp eq i64 %61, 0
%63 = getelementptr inbounds i8, i8* %59, i64 1
br i1 %62, label %58, label %64
64: ; preds = %58
%65 = load i8, i8* %59
%66 = icmp eq i8 %65, 10
br i1 %66, label %104, label %67
67: ; preds = %64
store i8 0, i8* %59
br label %68
68: ; preds = %73, %67
%69 = phi i8* [ %59, %67 ], [ %70, %73 ]
%70 = getelementptr inbounds i8, i8* %69, i64 1
%71 = load i8, i8* %70
%72 = icmp eq i8 %71, 10
br i1 %72, label %104, label %73
73: ; preds = %68
%74 = tail call i64 @isspace(i8 signext %71)
%75 = icmp eq i64 %74, 0
br i1 %75, label %76, label %68
76: ; preds = %73
%77 = load i8, i8* %70
%78 = icmp eq i8 %77, 10
br i1 %78, label %104, label %79
79: ; preds = %76
store i8* %70, i8** %4
br label %80
80: ; preds = %80, %79
%81 = phi i8* [ %70, %79 ], [ %85, %80 ]
%82 = load i8, i8* %81
%83 = tail call i64 @isspace(i8 signext %82)
%84 = icmp eq i64 %83, 0
%85 = getelementptr inbounds i8, i8* %81, i64 1
br i1 %84, label %80, label %86
86: ; preds = %80
%87 = load i8, i8* %81
%88 = icmp eq i8 %87, 10
br i1 %88, label %101, label %89
89: ; preds = %86
store i8 0, i8* %81
br label %90
90: ; preds = %95, %89
%91 = phi i8* [ %81, %89 ], [ %92, %95 ]
%92 = getelementptr inbounds i8, i8* %91, i64 1
%93 = load i8, i8* %92
%94 = icmp eq i8 %93, 10
br i1 %94, label %101, label %95
95: ; preds = %90
%96 = tail call i64 @isspace(i8 signext %93)
%97 = icmp eq i64 %96, 0
br i1 %97, label %98, label %90
98: ; preds = %95
%99 = load i8, i8* %92
%100 = icmp eq i8 %99, 10
br i1 %100, label %101, label %104
101: ; preds = %90, %98, %86
%102 = phi i8* [ %92, %98 ], [ %81, %86 ], [ %92, %90 ]
%103 = getelementptr inbounds i8, i8* %102, i64 1
store i8 0, i8* %102
store i8* %103, i8** %0
br label %104
104: ; preds = %68, %98, %76, %64, %45, %26, %101
%105 = phi i32 [ 0, %101 ], [ -1, %26 ], [ -1, %45 ], [ -1, %64 ], [ -1, %76 ], [ -1, %98 ], [ -1, %68 ]
ret i32 %105
}