#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 */
typedef size_t uint32_t;
typedef int int32_t;

/* Variables and functions */
size_t atoi(char *);
int find_symbol(char *, char, size_t);
int /*<<< orphan*/ free(char *);
void *malloc(size_t);
int /*<<< orphan*/ memcpy(char *, char *, size_t);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, size_t);
void parse_current_line(char *buff, uint32_t start, uint32_t end,
                        uint32_t **ppvertices, uint32_t *psize,
                        uint32_t *pname) {
  uint32_t len = end - start + 1, num_spaces = 0;
  char *local_buff = (char *)malloc(len);
  memset(local_buff, 0, len);
  memcpy(local_buff, &buff[start], len - 1);
  int32_t dash = find_symbol(local_buff, '-', len);
  uint32_t i;
  for (i = 0; i < len; i++) {
    if (local_buff[i] == '\n')
      local_buff[i] = 32;
    if (i > (dash + 2)) {
      if (local_buff[i] == ' ') {
        num_spaces++;
      }
    }
  }
  char *name = (char *)malloc(dash + 1);
  memset(name, 0, dash + 1);
  memcpy(name, local_buff, dash - 1);
  uint32_t uname = atoi(name);
  free(name);
  uint32_t *vert_arr = malloc(num_spaces * sizeof(uint32_t)), vert_count = 0;
  int32_t s1 = dash + 3, s2 = 0;
  for (i = dash + 4; i < len; i++) {
    if (local_buff[i] == ' ' && s1 == 0) {
      s1 = i;
    }
    if (local_buff[i] == ' ' && s2 == 0) {
      s2 = i;
    }
    if (s1 != 0 && s2 != 0) {
      char *vbuff = malloc(s2 - s1 + 1);
      memset(vbuff, 0, s2 - s1 + 1);
      memcpy(vbuff, &local_buff[s1], s2 - s1 + 1);
      vert_arr[vert_count] = (uint32_t)atoi(vbuff);
      vert_count++;
      free(vbuff);
      s1 = s2;
      s2 = 0;
    }
  }
  for (i = len - 1; i > 0; i--) {
    if (local_buff[i] == ' ') {
      char *vbuff = malloc(len - i + 1);
      memset(vbuff, 0, len - i + 1);
      memcpy(vbuff, &local_buff[s1], len - i);
      vert_arr[vert_count] = (uint32_t)atoi(vbuff);
      vert_count++;
      free(vbuff);
      break;
    }
  }
  if (pname != NULL)
    *pname = uname;
  if (psize != NULL)
    *psize = vert_count;
  if (ppvertices != NULL)
    *ppvertices = vert_arr;
  free(local_buff);
  return;
}


x86 assembly (clang, -O0):
<parse_current_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x18(%rbp),%rax
sub    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x48(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%rdx
sub    $0x1,%rdx
call   1060 <memcpy@plt>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x2d,%esi
call   1040 <find_symbol@plt>
mov    %eax,-0x4c(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    126e <parse_current_line+0x10e>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    121c <parse_current_line+0xbc>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jbe    1258 <parse_current_line+0xf8>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1253 <parse_current_line+0xf3>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1258 <parse_current_line+0xf8>
jmp    125d <parse_current_line+0xfd>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11ed <parse_current_line+0x8d>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x60(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
call   1060 <memcpy@plt>
mov    -0x60(%rbp),%rdi
call   1080 <atoi@plt>
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x4,%eax
cltq
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    140e <parse_current_line+0x2ae>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1329 <parse_current_line+0x1c9>
cmpl   $0x0,-0x7c(%rbp)
jne    1329 <parse_current_line+0x1c9>
mov    -0x58(%rbp),%rax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    134f <parse_current_line+0x1ef>
cmpl   $0x0,-0x80(%rbp)
jne    134f <parse_current_line+0x1ef>
mov    -0x58(%rbp),%rax
mov    %eax,-0x80(%rbp)
cmpl   $0x0,-0x7c(%rbp)
je     13f8 <parse_current_line+0x298>
cmpl   $0x0,-0x80(%rbp)
je     13f8 <parse_current_line+0x298>
mov    -0x80(%rbp),%eax
sub    -0x7c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x80(%rbp),%eax
sub    -0x7c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x88(%rbp),%rdi
mov    -0x48(%rbp),%rsi
movslq -0x7c(%rbp),%rax
add    %rax,%rsi
mov    -0x80(%rbp),%eax
sub    -0x7c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
call   1060 <memcpy@plt>
mov    -0x88(%rbp),%rdi
call   1080 <atoi@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
jmp    13fd <parse_current_line+0x29d>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    12f5 <parse_current_line+0x195>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jbe    14d9 <parse_current_line+0x379>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    14c3 <parse_current_line+0x363>
mov    -0x38(%rbp),%rdi
sub    -0x58(%rbp),%rdi
add    $0x1,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%rdx
sub    -0x58(%rbp),%rdx
add    $0x1,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x90(%rbp),%rdi
mov    -0x48(%rbp),%rsi
movslq -0x7c(%rbp),%rax
add    %rax,%rsi
mov    -0x38(%rbp),%rdx
sub    -0x58(%rbp),%rdx
call   1060 <memcpy@plt>
mov    -0x90(%rbp),%rdi
call   1080 <atoi@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
jmp    14d9 <parse_current_line+0x379>
jmp    14c8 <parse_current_line+0x368>
mov    -0x58(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
jmp    141a <parse_current_line+0x2ba>
cmpq   $0x0,-0x30(%rbp)
je     14ef <parse_current_line+0x38f>
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
cmpq   $0x0,-0x28(%rbp)
je     1505 <parse_current_line+0x3a5>
mov    -0x78(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
cmpq   $0x0,-0x20(%rbp)
je     151b <parse_current_line+0x3bb>
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_current_line>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x8(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
mov    %rdx,0x38(%rsp)
sub    %rsi,%rbx
lea    0x1(%rbx),%r12
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,%r13
xor    %ebp,%ebp
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1050 <memset@plt>
add    %r14,%r15
mov    %r13,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
call   1060 <memcpy@plt>
mov    %r13,%rdi
mov    $0x2d,%esi
mov    %r12,%rdx
call   1040 <find_symbol@plt>
mov    %rbx,%r8
inc    %r8
mov    %r8,0x28(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
je     128d <parse_current_line+0x12d>
lea    0x2(%rax),%ecx
movslq %ecx,%rdi
test   %rbx,%rbx
je     1259 <parse_current_line+0xf9>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebp,%ebp
xor    %ecx,%ecx
jmp    121d <parse_current_line+0xbd>
cmp    %rdi,%rcx
setae  %dl
cmp    $0x20,%bl
sete   %bl
and    %dl,%bl
movzbl %bl,%edx
add    %rdx,%rbp
add    $0x2,%rcx
cmp    %rcx,%rsi
je     125d <parse_current_line+0xfd>
movzbl 0x0(%r13,%rcx,1),%ebx
cmp    $0xa,%bl
jne    1230 <parse_current_line+0xd0>
movb   $0x20,0x0(%r13,%rcx,1)
mov    $0x20,%bl
cmp    %rdi,%rcx
seta   %dl
cmp    $0x20,%bl
sete   %bl
and    %dl,%bl
movzbl %bl,%edx
add    %rdx,%rbp
movzbl 0x1(%r13,%rcx,1),%ebx
cmp    $0xa,%bl
jne    1200 <parse_current_line+0xa0>
movb   $0x20,0x1(%r13,%rcx,1)
mov    $0x20,%bl
jmp    1200 <parse_current_line+0xa0>
xor    %ebp,%ebp
xor    %ecx,%ecx
test   $0x1,%r8b
je     1289 <parse_current_line+0x129>
mov    0x0(%r13,%rcx,1),%dl
cmp    $0xa,%dl
jne    1275 <parse_current_line+0x115>
movb   $0x20,0x0(%r13,%rcx,1)
mov    $0x20,%dl
cmp    %rdi,%rcx
seta   %bl
cmp    $0x20,%dl
sete   %cl
and    %bl,%cl
movzbl %cl,%ecx
add    %rcx,%rbp
shl    $0x3,%rbp
lea    0x1(%rax),%ecx
movslq %ecx,%r15
mov    %r15,%rdi
mov    %rax,%rbx
call   1070 <malloc@plt>
mov    %rax,%r12
xor    %r14d,%r14d
mov    %rax,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
lea    -0x1(%rbx),%eax
movslq %eax,%rdx
mov    %r12,%rdi
mov    %r13,%rsi
call   1060 <memcpy@plt>
mov    %r12,%rdi
call   1080 <atoi@plt>
mov    %rax,0x30(%rsp)
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
lea    0x3(%rbx),%r15d
add    $0x4,%ebx
movslq %ebx,%r12
mov    0x28(%rsp),%rdx
xor    %ebp,%ebp
cmp    %r12,%rdx
ja     1349 <parse_current_line+0x1e9>
mov    0x48(%rsp),%rdx
test   %rdx,%rdx
je     1441 <parse_current_line+0x2e1>
mov    0x40(%rsp),%rcx
sub    0x38(%rsp),%rcx
add    %r13,%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
cmpb   $0x20,(%rdx,%rax,1)
je     13e1 <parse_current_line+0x281>
add    $0xffffffffffffffff,%rax
cmp    %rax,%rcx
jne    1320 <parse_current_line+0x1c0>
jmp    1441 <parse_current_line+0x2e1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %rdx,%r12
jae    12fa <parse_current_line+0x19a>
mov    %r15d,%eax
test   %r15d,%r15d
cmove  %r12d,%r15d
mov    %r14d,%ecx
test   %r14d,%r14d
cmove  %r12d,%r14d
cmpb   $0x20,0x0(%r13,%r12,1)
cmovne %eax,%r15d
cmovne %ecx,%r14d
test   %r15d,%r15d
je     1340 <parse_current_line+0x1e0>
test   %r14d,%r14d
je     1340 <parse_current_line+0x1e0>
mov    %r14d,%eax
sub    %r15d,%eax
add    $0x1,%eax
mov    %rbp,0x50(%rsp)
movslq %eax,%rbp
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
movslq %r15d,%rsi
add    %r13,%rsi
mov    %rbx,%rdi
mov    %rbp,%rdx
mov    0x50(%rsp),%rbp
call   1060 <memcpy@plt>
mov    %rbx,%rdi
call   1080 <atoi@plt>
mov    0x20(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
add    $0x1,%rbp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdx
mov    %r14d,%r15d
xor    %r14d,%r14d
jmp    1340 <parse_current_line+0x1e0>
mov    $0x1,%r14d
sub    %rax,%r14
mov    %rbp,%r12
mov    $0x2,%ebp
sub    %rax,%rbp
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
mov    %r12,%rbp
call   1050 <memset@plt>
movslq %r15d,%rax
mov    %r13,%rsi
add    %rax,%rsi
mov    %rbx,%rdi
mov    %r14,%rdx
call   1060 <memcpy@plt>
mov    %rbx,%rdi
call   1080 <atoi@plt>
mov    0x20(%rsp),%rcx
mov    %rax,(%rcx,%r12,8)
add    $0x1,%rbp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%rdx
test   %rdx,%rdx
je     145d <parse_current_line+0x2fd>
mov    0x30(%rsp),%rsi
mov    %rsi,(%rdx)
test   %rcx,%rcx
je     1465 <parse_current_line+0x305>
mov    %rbp,(%rcx)
test   %rax,%rax
je     1472 <parse_current_line+0x312>
mov    0x20(%rsp),%rcx
mov    %rcx,(%rax)
mov    %r13,%rdi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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