#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*/ memset(char *, int /*<<< orphan*/, int);
float stringToFloat(char *);
int parse(char *buff, int len, float *q) {
  int i = 0;
  int j = 0;
  char data[10];
  memset(data, 0, 10);
  for (i = 0; i < len; i++) {
    if (buff[i] == 'r' && buff[i + 1] == ':') {
      i += 2;
      break;
    }
  }
  j = 0;
  while (buff[i] != ' ') {
    data[j] = buff[i];
    j++;
    i++;
  }
  q[0] = stringToFloat(data);
  memset(data, 0, 10);
  for (; i < len; i++) {
    if (buff[i] == 'i' && buff[i + 1] == ':') {
      i += 2;
      break;
    }
  }
  j = 0;
  while (buff[i] != ' ') {
    data[j] = buff[i];
    j++;
    i++;
  }
  q[1] = stringToFloat(data);
  memset(data, 0, 10);
  for (; i < len; i++) {
    if (buff[i] == 'j' && buff[i + 1] == ':') {
      i += 2;
      break;
    }
  }
  j = 0;
  while (buff[i] != ' ') {
    data[j] = buff[i];
    j++;
    i++;
  }
  q[2] = stringToFloat(data);
  memset(data, 0, 10);
  for (; i < len; i++) {
    if (buff[i] == 'k' && buff[i + 1] == ':') {
      i += 2;
      break;
    }
  }
  j = 0;
  while (buff[i] != '\n') {
    data[j] = buff[i];
    j++;
    i++;
  }
  q[3] = stringToFloat(data);
  return 0;
}


x86 assembly (clang, -O0):
<parse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
lea    -0x2a(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b4 <parse+0x94>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x72,%eax
jne    11a1 <parse+0x81>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    11a1 <parse+0x81>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b4 <parse+0x94>
jmp    11a6 <parse+0x86>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1158 <parse+0x38>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     11fa <parse+0xda>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11bb <parse+0x9b>
lea    -0x2a(%rbp),%rdi
call   1040 <stringToFloat@plt>
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
lea    -0x2a(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1277 <parse+0x157>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x69,%eax
jne    1264 <parse+0x144>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    1264 <parse+0x144>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1277 <parse+0x157>
jmp    1269 <parse+0x149>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    121b <parse+0xfb>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     12bd <parse+0x19d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    127e <parse+0x15e>
lea    -0x2a(%rbp),%rdi
call   1040 <stringToFloat@plt>
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
lea    -0x2a(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    133b <parse+0x21b>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6a,%eax
jne    1328 <parse+0x208>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    1328 <parse+0x208>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    133b <parse+0x21b>
jmp    132d <parse+0x20d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12df <parse+0x1bf>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1381 <parse+0x261>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1342 <parse+0x222>
lea    -0x2a(%rbp),%rdi
call   1040 <stringToFloat@plt>
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
lea    -0x2a(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ff <parse+0x2df>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6b,%eax
jne    13ec <parse+0x2cc>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    13ec <parse+0x2cc>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    13ff <parse+0x2df>
jmp    13f1 <parse+0x2d1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13a3 <parse+0x283>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     1445 <parse+0x325>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1406 <parse+0x2e6>
lea    -0x2a(%rbp),%rdi
call   1040 <stringToFloat@plt>
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rdx,%r14
mov    %esi,%r15d
mov    %rdi,%rbx
lea    0x6(%rsp),%rdi
xor    %ebp,%ebp
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
test   %r15d,%r15d
jle    117d <parse+0x5d>
mov    %r15d,%eax
xor    %ebp,%ebp
jmp    1169 <parse+0x49>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rbp,%rax
je     117b <parse+0x5b>
cmpb   $0x72,(%rbx,%rbp,1)
jne    1160 <parse+0x40>
cmpb   $0x3a,0x1(%rbx,%rbp,1)
jne    1160 <parse+0x40>
add    $0x2,%ebp
jmp    117d <parse+0x5d>
mov    %eax,%ebp
movslq %ebp,%rcx
mov    (%rbx,%rcx,1),%al
cmp    $0x20,%al
je     11b2 <parse+0x92>
lea    (%rcx,%rbx,1),%rdx
add    $0x1,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %al,0x6(%rsp,%rcx,1)
movzbl (%rdx,%rcx,1),%eax
add    $0x1,%rcx
cmp    $0x20,%al
jne    11a0 <parse+0x80>
add    %ecx,%ebp
lea    0x6(%rsp),%r12
mov    %r12,%rdi
call   1040 <stringToFloat@plt>
movss  %xmm0,(%r14)
mov    %r12,%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
cmp    %r15d,%ebp
jge    1210 <parse+0xf0>
movslq %ebp,%rax
movslq %r15d,%rcx
sub    %rax,%rcx
lea    (%rax,%rbx,1),%rdx
add    $0x1,%rdx
xor    %eax,%eax
jmp    11f9 <parse+0xd9>
nopl   (%rax)
add    $0x1,%rax
cmp    %rax,%rcx
je     120d <parse+0xed>
cmpb   $0x69,-0x1(%rdx,%rax,1)
jne    11f0 <parse+0xd0>
cmpb   $0x3a,(%rdx,%rax,1)
jne    11f0 <parse+0xd0>
add    %eax,%ebp
add    $0x2,%ebp
jmp    1210 <parse+0xf0>
mov    %r15d,%ebp
movslq %ebp,%rcx
mov    (%rbx,%rcx,1),%al
cmp    $0x20,%al
je     1242 <parse+0x122>
lea    (%rcx,%rbx,1),%rdx
add    $0x1,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %al,0x6(%rsp,%rcx,1)
movzbl (%rdx,%rcx,1),%eax
add    $0x1,%rcx
cmp    $0x20,%al
jne    1230 <parse+0x110>
add    %ecx,%ebp
lea    0x6(%rsp),%r12
mov    %r12,%rdi
call   1040 <stringToFloat@plt>
movss  %xmm0,0x4(%r14)
mov    %r12,%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
cmp    %r15d,%ebp
jge    12a0 <parse+0x180>
movslq %ebp,%rax
movslq %r15d,%rcx
sub    %rax,%rcx
lea    (%rax,%rbx,1),%rdx
add    $0x1,%rdx
xor    %eax,%eax
jmp    1289 <parse+0x169>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rax,%rcx
je     129d <parse+0x17d>
cmpb   $0x6a,-0x1(%rdx,%rax,1)
jne    1280 <parse+0x160>
cmpb   $0x3a,(%rdx,%rax,1)
jne    1280 <parse+0x160>
add    %eax,%ebp
add    $0x2,%ebp
jmp    12a0 <parse+0x180>
mov    %r15d,%ebp
movslq %ebp,%rcx
mov    (%rbx,%rcx,1),%al
cmp    $0x20,%al
je     12d2 <parse+0x1b2>
lea    (%rcx,%rbx,1),%rdx
add    $0x1,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %al,0x6(%rsp,%rcx,1)
movzbl (%rdx,%rcx,1),%eax
add    $0x1,%rcx
cmp    $0x20,%al
jne    12c0 <parse+0x1a0>
add    %ecx,%ebp
lea    0x6(%rsp),%r12
mov    %r12,%rdi
call   1040 <stringToFloat@plt>
movss  %xmm0,0x8(%r14)
mov    %r12,%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1030 <memset@plt>
cmp    %r15d,%ebp
jge    1330 <parse+0x210>
movslq %ebp,%rax
movslq %r15d,%rcx
sub    %rax,%rcx
lea    (%rax,%rbx,1),%rdx
add    $0x1,%rdx
xor    %eax,%eax
jmp    1319 <parse+0x1f9>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rax,%rcx
je     132d <parse+0x20d>
cmpb   $0x6b,-0x1(%rdx,%rax,1)
jne    1310 <parse+0x1f0>
cmpb   $0x3a,(%rdx,%rax,1)
jne    1310 <parse+0x1f0>
add    %eax,%ebp
add    $0x2,%ebp
jmp    1330 <parse+0x210>
mov    %r15d,%ebp
movslq %ebp,%rcx
mov    (%rbx,%rcx,1),%al
cmp    $0xa,%al
je     1360 <parse+0x240>
add    %rbx,%rcx
add    $0x1,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %al,0x6(%rsp,%rdx,1)
movzbl (%rcx,%rdx,1),%eax
add    $0x1,%rdx
cmp    $0xa,%al
jne    1350 <parse+0x230>
lea    0x6(%rsp),%rdi
call   1040 <stringToFloat@plt>
movss  %xmm0,0xc(%r14)
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @parse(i8* %0, i32 %1, float* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca float*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [10 x i8]
store i8* %0, i8** %4
store i32 %1, i32* %5
store float* %2, float** %6
store i32 0, i32* %7
store i32 0, i32* %8
%10 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%11 = call i32 @memset(i8* %10, i32 0, i32 10)
store i32 0, i32* %7
br label %12
12: ; preds = %37, %3
%13 = load i32, i32* %7
%14 = load i32, i32* %5
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %40
16: ; preds = %12
%17 = load i8*, i8** %4
%18 = load i32, i32* %7
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 114
br i1 %23, label %24, label %36
24: ; preds = %16
%25 = load i8*, i8** %4
%26 = load i32, i32* %7
%27 = add nsw i32 %26, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %25, i64 %28
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
%32 = icmp eq i32 %31, 58
br i1 %32, label %33, label %36
33: ; preds = %24
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 2
store i32 %35, i32* %7
br label %40
36: ; preds = %24, %16
br label %37
37: ; preds = %36
%38 = load i32, i32* %7
%39 = add nsw i32 %38, 1
store i32 %39, i32* %7
br label %12
40: ; preds = %33, %12
store i32 0, i32* %8
br label %41
41: ; preds = %49, %40
%42 = load i8*, i8** %4
%43 = load i32, i32* %7
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp ne i32 %47, 32
br i1 %48, label %49, label %62
49: ; preds = %41
%50 = load i8*, i8** %4
%51 = load i32, i32* %7
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
%54 = load i8, i8* %53
%55 = load i32, i32* %8
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %56
store i8 %54, i8* %57
%58 = load i32, i32* %8
%59 = add nsw i32 %58, 1
store i32 %59, i32* %8
%60 = load i32, i32* %7
%61 = add nsw i32 %60, 1
store i32 %61, i32* %7
br label %41
62: ; preds = %41
%63 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%64 = call float @stringToFloat(i8* %63)
%65 = load float*, float** %6
%66 = getelementptr inbounds float, float* %65, i64 0
store float %64, float* %66
%67 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%68 = call i32 @memset(i8* %67, i32 0, i32 10)
br label %69
69: ; preds = %94, %62
%70 = load i32, i32* %7
%71 = load i32, i32* %5
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %97
73: ; preds = %69
%74 = load i8*, i8** %4
%75 = load i32, i32* %7
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp eq i32 %79, 105
br i1 %80, label %81, label %93
81: ; preds = %73
%82 = load i8*, i8** %4
%83 = load i32, i32* %7
%84 = add nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %82, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp eq i32 %88, 58
br i1 %89, label %90, label %93
90: ; preds = %81
%91 = load i32, i32* %7
%92 = add nsw i32 %91, 2
store i32 %92, i32* %7
br label %97
93: ; preds = %81, %73
br label %94
94: ; preds = %93
%95 = load i32, i32* %7
%96 = add nsw i32 %95, 1
store i32 %96, i32* %7
br label %69
97: ; preds = %90, %69
store i32 0, i32* %8
br label %98
98: ; preds = %106, %97
%99 = load i8*, i8** %4
%100 = load i32, i32* %7
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %99, i64 %101
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = icmp ne i32 %104, 32
br i1 %105, label %106, label %119
106: ; preds = %98
%107 = load i8*, i8** %4
%108 = load i32, i32* %7
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = load i8, i8* %110
%112 = load i32, i32* %8
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %113
store i8 %111, i8* %114
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 1
store i32 %116, i32* %8
%117 = load i32, i32* %7
%118 = add nsw i32 %117, 1
store i32 %118, i32* %7
br label %98
119: ; preds = %98
%120 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%121 = call float @stringToFloat(i8* %120)
%122 = load float*, float** %6
%123 = getelementptr inbounds float, float* %122, i64 1
store float %121, float* %123
%124 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%125 = call i32 @memset(i8* %124, i32 0, i32 10)
br label %126
126: ; preds = %151, %119
%127 = load i32, i32* %7
%128 = load i32, i32* %5
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %154
130: ; preds = %126
%131 = load i8*, i8** %4
%132 = load i32, i32* %7
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = load i8, i8* %134
%136 = sext i8 %135 to i32
%137 = icmp eq i32 %136, 106
br i1 %137, label %138, label %150
138: ; preds = %130
%139 = load i8*, i8** %4
%140 = load i32, i32* %7
%141 = add nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %139, i64 %142
%144 = load i8, i8* %143
%145 = sext i8 %144 to i32
%146 = icmp eq i32 %145, 58
br i1 %146, label %147, label %150
147: ; preds = %138
%148 = load i32, i32* %7
%149 = add nsw i32 %148, 2
store i32 %149, i32* %7
br label %154
150: ; preds = %138, %130
br label %151
151: ; preds = %150
%152 = load i32, i32* %7
%153 = add nsw i32 %152, 1
store i32 %153, i32* %7
br label %126
154: ; preds = %147, %126
store i32 0, i32* %8
br label %155
155: ; preds = %163, %154
%156 = load i8*, i8** %4
%157 = load i32, i32* %7
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8, i8* %156, i64 %158
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = icmp ne i32 %161, 32
br i1 %162, label %163, label %176
163: ; preds = %155
%164 = load i8*, i8** %4
%165 = load i32, i32* %7
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %164, i64 %166
%168 = load i8, i8* %167
%169 = load i32, i32* %8
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %170
store i8 %168, i8* %171
%172 = load i32, i32* %8
%173 = add nsw i32 %172, 1
store i32 %173, i32* %8
%174 = load i32, i32* %7
%175 = add nsw i32 %174, 1
store i32 %175, i32* %7
br label %155
176: ; preds = %155
%177 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%178 = call float @stringToFloat(i8* %177)
%179 = load float*, float** %6
%180 = getelementptr inbounds float, float* %179, i64 2
store float %178, float* %180
%181 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%182 = call i32 @memset(i8* %181, i32 0, i32 10)
br label %183
183: ; preds = %208, %176
%184 = load i32, i32* %7
%185 = load i32, i32* %5
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %211
187: ; preds = %183
%188 = load i8*, i8** %4
%189 = load i32, i32* %7
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp eq i32 %193, 107
br i1 %194, label %195, label %207
195: ; preds = %187
%196 = load i8*, i8** %4
%197 = load i32, i32* %7
%198 = add nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %196, i64 %199
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
%203 = icmp eq i32 %202, 58
br i1 %203, label %204, label %207
204: ; preds = %195
%205 = load i32, i32* %7
%206 = add nsw i32 %205, 2
store i32 %206, i32* %7
br label %211
207: ; preds = %195, %187
br label %208
208: ; preds = %207
%209 = load i32, i32* %7
%210 = add nsw i32 %209, 1
store i32 %210, i32* %7
br label %183
211: ; preds = %204, %183
store i32 0, i32* %8
br label %212
212: ; preds = %220, %211
%213 = load i8*, i8** %4
%214 = load i32, i32* %7
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %213, i64 %215
%217 = load i8, i8* %216
%218 = sext i8 %217 to i32
%219 = icmp ne i32 %218, 10
br i1 %219, label %220, label %233
220: ; preds = %212
%221 = load i8*, i8** %4
%222 = load i32, i32* %7
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %221, i64 %223
%225 = load i8, i8* %224
%226 = load i32, i32* %8
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 %227
store i8 %225, i8* %228
%229 = load i32, i32* %8
%230 = add nsw i32 %229, 1
store i32 %230, i32* %8
%231 = load i32, i32* %7
%232 = add nsw i32 %231, 1
store i32 %232, i32* %7
br label %212
233: ; preds = %212
%234 = getelementptr inbounds [10 x i8], [10 x i8]* %9, i64 0, i64 0
%235 = call float @stringToFloat(i8* %234)
%236 = load float*, float** %6
%237 = getelementptr inbounds float, float* %236, i64 3
store float %235, float* %237
ret i32 0
}

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