#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 int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ SEEK_END;
int /*<<< orphan*/ SEEK_SET;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fread(char *, int, unsigned long, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int /*<<< orphan*/,
                         int /*<<< orphan*/);
unsigned long ftell(int /*<<< orphan*/ *);
void *malloc(int);
int /*<<< orphan*/ memset(char *, char, int);
int /*<<< orphan*/ puts(char *);
int strlen(char *);
int /*<<< orphan*/ strncpy(int /*<<< orphan*/, char *, int);
unsigned long parse_str_str_map(FILE *fp, char delim, char ***Col1,
                                char ***Col2) {
  fseek(fp, 0, SEEK_END);
  unsigned long ixSize = ftell(fp);
  fseek(fp, 0, SEEK_SET);
  char *ixStr = malloc(ixSize + 1);
  if (!ixStr) {
    puts("PSM out of memory.\n");
    return 0;
  }
  fread(ixStr, 1, ixSize, fp);
  fclose(fp);
  ixStr[ixSize] = 0;
  unsigned long ilines = 0;
  char *iix = ixStr;
  while (*iix)
    ilines += *iix++ == '\n';
  *Col1 = malloc(ilines * sizeof(char *));
  *Col2 = malloc(ilines * sizeof(char *));
  if (!*Col1 || !*Col2) {
    puts("PSS out of memory.\n");
    return 0;
  }
  char **Col1p = *Col1, **Col2p = *Col2;
  int which = 0;
  char *buffer = malloc(10000), *bufp = buffer;
  iix = ixStr;
  char c;
  while ((c = *iix++)) {
    if (c == '\n' || c == delim) {
      memset(bufp, '\0', 1);
      if (!which) {
        if (*(bufp - 1) == '\r')
          memset(bufp - 1, '\0', 1);
        int amt;
        *Col1p = malloc(amt = strlen(buffer) + 1);
        if (!*Col1p)
          return 0;
        strncpy(*Col1p++, buffer, amt);
      } else {
        if (*(bufp - 1) == '\r')
          memset(bufp - 1, '\0', 1);
        int amt;
        *Col2p = malloc(amt = strlen(buffer) + 1);
        if (!*Col2p)
          return 0;
        strncpy(*Col2p++, buffer, amt);
      }
      which ^= 1;
      bufp = buffer;
    } else
      *bufp++ = c;
  }
  free(ixStr);
  return ilines;
}


x86 assembly (clang, -O0):
<parse_str_str_map>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %sil,%al
mov    %rdi,-0x10(%rbp)
mov    %al,-0x11(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    0x2e20(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   10c0 <fseek@plt>
mov    -0x10(%rbp),%rdi
call   10a0 <ftell@plt>
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
mov    0x2def(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   10c0 <fseek@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    1229 <parse_str_str_map+0x89>
lea    0xde9(%rip),%rdi
call   1050 <puts@plt>
movq   $0x0,-0x8(%rbp)
jmp    14d7 <parse_str_str_map+0x337>
mov    -0x38(%rbp),%rdi
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rcx
mov    $0x1,%esi
call   1060 <fread@plt>
mov    -0x10(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movq   $0x0,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmpb   $0x0,(%rax)
je     129d <parse_str_str_map+0xfd>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cltq
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    1264 <parse_str_str_map+0xc4>
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
cmpq   $0x0,(%rax)
je     12eb <parse_str_str_map+0x14b>
mov    -0x28(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1304 <parse_str_str_map+0x164>
lea    0xd22(%rip),%rdi
call   1050 <puts@plt>
movq   $0x0,-0x8(%rbp)
jmp    14d7 <parse_str_str_map+0x337>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    $0x2710,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
mov    (%rax),%al
mov    %al,-0x71(%rbp)
cmp    $0x0,%al
je     14c6 <parse_str_str_map+0x326>
movsbl -0x71(%rbp),%eax
cmp    $0xa,%eax
je     1378 <parse_str_str_map+0x1d8>
movsbl -0x71(%rbp),%eax
movsbl -0x11(%rbp),%ecx
cmp    %ecx,%eax
jne    14ad <parse_str_str_map+0x30d>
mov    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
cmpl   $0x0,-0x5c(%rbp)
jne    1417 <parse_str_str_map+0x277>
mov    -0x70(%rbp),%rax
movsbl -0x1(%rax),%eax
cmp    $0xd,%eax
jne    13b7 <parse_str_str_map+0x217>
mov    -0x70(%rbp),%rdi
add    $0xffffffffffffffff,%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
mov    -0x68(%rbp),%rdi
call   1080 <strlen@plt>
mov    %eax,%edi
add    $0x1,%edi
mov    %edi,-0x78(%rbp)
call   10b0 <malloc@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x50(%rbp),%rax
cmpq   $0x0,(%rax)
jne    13f2 <parse_str_str_map+0x252>
movq   $0x0,-0x8(%rbp)
jmp    14d7 <parse_str_str_map+0x337>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x68(%rbp),%rsi
mov    -0x78(%rbp),%edx
call   1040 <strncpy@plt>
jmp    1497 <parse_str_str_map+0x2f7>
mov    -0x70(%rbp),%rax
movsbl -0x1(%rax),%eax
cmp    $0xd,%eax
jne    143c <parse_str_str_map+0x29c>
mov    -0x70(%rbp),%rdi
add    $0xffffffffffffffff,%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
mov    -0x68(%rbp),%rdi
call   1080 <strlen@plt>
mov    %eax,%edi
add    $0x1,%edi
mov    %edi,-0x7c(%rbp)
call   10b0 <malloc@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x58(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1477 <parse_str_str_map+0x2d7>
movq   $0x0,-0x8(%rbp)
jmp    14d7 <parse_str_str_map+0x337>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
mov    -0x68(%rbp),%rsi
mov    -0x7c(%rbp),%edx
call   1040 <strncpy@plt>
mov    -0x5c(%rbp),%eax
xor    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    14c1 <parse_str_str_map+0x321>
mov    -0x71(%rbp),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,(%rax)
jmp    133f <parse_str_str_map+0x19f>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_str_str_map>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r15
mov    %rdx,%r13
mov    %esi,0xc(%rsp)
mov    %rdi,%rbp
mov    0x2e26(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   10c0 <fseek@plt>
mov    %rbp,%rdi
call   10a0 <ftell@plt>
mov    %rax,%rbx
mov    0x2dfb(%rip),%rax
mov    (%rax),%edx
mov    %rbp,%rdi
xor    %esi,%esi
call   10c0 <fseek@plt>
lea    0x1(%rbx),%edi
call   10b0 <malloc@plt>
test   %rax,%rax
je     1248 <parse_str_str_map+0xa8>
mov    %rax,%r14
mov    %rax,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
mov    %rbp,%rcx
call   1060 <fread@plt>
mov    %rbp,%rdi
call   1070 <fclose@plt>
movb   $0x0,(%r14,%rbx,1)
mov    (%r14),%r12b
test   %r12b,%r12b
je     1254 <parse_str_str_map+0xb4>
lea    0x1(%r14),%rax
xor    %ebp,%ebp
mov    %r12d,%ecx
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cmp    $0xa,%cl
sete   %dl
add    %rdx,%rbp
movzbl (%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    1230 <parse_str_str_map+0x90>
jmp    1256 <parse_str_str_map+0xb6>
lea    0xdb1(%rip),%rdi
jmp    13a3 <parse_str_str_map+0x203>
xor    %ebp,%ebp
lea    0x0(,%rbp,8),%ebx
mov    %ebx,%edi
call   10b0 <malloc@plt>
mov    %rax,0x0(%r13)
mov    %ebx,%edi
call   10b0 <malloc@plt>
mov    %rax,(%r15)
test   %rax,%rax
je     139c <parse_str_str_map+0x1fc>
mov    0x0(%r13),%rcx
test   %rcx,%rcx
je     139c <parse_str_str_map+0x1fc>
mov    %rcx,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x2710,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %r14,0x20(%rsp)
mov    %r14,%r15
add    $0x1,%r15
xor    %r14d,%r14d
mov    %rax,%rbx
jmp    1309 <parse_str_str_map+0x169>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
call   1080 <strlen@plt>
mov    %eax,%ebx
add    $0x1,%ebx
mov    %ebx,%edi
call   10b0 <malloc@plt>
mov    0x18(%rsp),%rcx
mov    %rax,(%rcx)
test   %rax,%rax
je     13a8 <parse_str_str_map+0x208>
add    $0x8,%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,%edi
mov    %r13,%rsi
mov    %ebx,%edx
call   1040 <strncpy@plt>
xor    $0x1,%r14d
mov    %r13,%rbx
movzbl (%r15),%r12d
add    $0x1,%r15
cmp    $0xa,%r12b
je     131f <parse_str_str_map+0x17f>
test   %r12b,%r12b
je     13bc <parse_str_str_map+0x21c>
cmp    0xc(%rsp),%r12b
jne    1390 <parse_str_str_map+0x1f0>
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
lea    -0x1(%rbx),%rdi
movzbl -0x1(%rbx),%eax
test   %r14d,%r14d
je     1350 <parse_str_str_map+0x1b0>
cmp    $0xd,%al
jne    12c0 <parse_str_str_map+0x120>
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
jmp    12c0 <parse_str_str_map+0x120>
cmp    $0xd,%al
jne    1360 <parse_str_str_map+0x1c0>
xor    %esi,%esi
mov    $0x1,%edx
call   1090 <memset@plt>
mov    %r13,%rdi
call   1080 <strlen@plt>
mov    %eax,%ebx
add    $0x1,%ebx
mov    %ebx,%edi
call   10b0 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
test   %rax,%rax
je     13a8 <parse_str_str_map+0x208>
add    $0x8,%rcx
mov    %rcx,0x10(%rsp)
jmp    12ee <parse_str_str_map+0x14e>
nop
mov    %r12b,(%rbx)
add    $0x1,%rbx
jmp    1301 <parse_str_str_map+0x161>
lea    0xc71(%rip),%rdi
call   1050 <puts@plt>
xor    %ebp,%ebp
mov    %rbp,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
jmp    13aa <parse_str_str_map+0x20a>

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

LLVM IR (-O2):
@SEEK_END = global i32 0
@SEEK_SET = global i32 0
@.str = [20 x i8] c"PSM out of memory.\0A\00"
@.str.1 = [20 x i8] c"PSS out of memory.\0A\00"
define i64 @parse_str_str_map(i32* nocapture %0, i8 signext %1, i8*** nocapture %2, i8*** nocapture writeonly %3) {
%5 = load i32, i32* @SEEK_END
%6 = tail call i32 @fseek(i32* %0, i32 0, i32 %5)
%7 = tail call i64 @ftell(i32* %0)
%8 = load i32, i32* @SEEK_SET
%9 = tail call i32 @fseek(i32* %0, i32 0, i32 %8)
%10 = trunc i64 %7 to i32
%11 = add i32 %10, 1
%12 = tail call i8* @malloc(i32 %11)
%13 = icmp eq i8* %12, null
br i1 %13, label %14, label %16
14: ; preds = %4
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
br label %104
16: ; preds = %4
%17 = tail call i32 @fread(i8* %12, i32 1, i64 %7, i32* %0)
%18 = tail call i32 @fclose(i32* %0)
%19 = getelementptr inbounds i8, i8* %12, i64 %7
store i8 0, i8* %19
%20 = load i8, i8* %12
%21 = icmp eq i8 %20, 0
br i1 %21, label %32, label %22
22: ; preds = %16, %22
%23 = phi i8 [ %30, %22 ], [ %20, %16 ]
%24 = phi i64 [ %29, %22 ], [ 0, %16 ]
%25 = phi i8* [ %26, %22 ], [ %12, %16 ]
%26 = getelementptr inbounds i8, i8* %25, i64 1
%27 = icmp eq i8 %23, 10
%28 = zext i1 %27 to i64
%29 = add i64 %24, %28
%30 = load i8, i8* %26
%31 = icmp eq i8 %30, 0
br i1 %31, label %32, label %22
32: ; preds = %22, %16
%33 = phi i64 [ 0, %16 ], [ %29, %22 ]
%34 = trunc i64 %33 to i32
%35 = shl i32 %34, 3
%36 = tail call i8* @malloc(i32 %35)
%37 = bitcast i8*** %2 to i8**
store i8* %36, i8** %37
%38 = tail call i8* @malloc(i32 %35)
%39 = bitcast i8*** %3 to i8**
store i8* %38, i8** %39
%40 = load i8**, i8*** %2
%41 = icmp eq i8** %40, null
%42 = icmp eq i8* %38, null
%43 = or i1 %42, %41
br i1 %43, label %44, label %46
44: ; preds = %32
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0))
br label %104
46: ; preds = %32
%47 = bitcast i8* %38 to i8**
%48 = tail call dereferenceable_or_null(10000) i8* @malloc(i32 10000)
br label %49
49: ; preds = %96, %46
%50 = phi i8 [ %20, %46 ], [ %101, %96 ]
%51 = phi i8** [ %40, %46 ], [ %97, %96 ]
%52 = phi i8** [ %47, %46 ], [ %98, %96 ]
%53 = phi i32 [ 0, %46 ], [ %99, %96 ]
%54 = phi i8* [ %12, %46 ], [ %56, %96 ]
%55 = phi i8* [ %48, %46 ], [ %100, %96 ]
%56 = getelementptr inbounds i8, i8* %54, i64 1
switch i8 %50, label %57 [
i8 0, label %102
i8 10, label %59
]
57: ; preds = %49
%58 = icmp eq i8 %50, %1
br i1 %58, label %59, label %94
59: ; preds = %49, %57
%60 = tail call i32 @memset(i8* %55, i8 signext 0, i32 1)
%61 = icmp eq i32 %53, 0
%62 = getelementptr inbounds i8, i8* %55, i64 -1
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, 13
br i1 %61, label %65, label %75
65: ; preds = %59
br i1 %64, label %66, label %68
66: ; preds = %65
%67 = tail call i32 @memset(i8* %62, i8 signext 0, i32 1)
br label %68
68: ; preds = %66, %65
%69 = tail call i32 @strlen(i8* %48)
%70 = add nsw i32 %69, 1
%71 = tail call i8* @malloc(i32 %70)
store i8* %71, i8** %51
%72 = icmp eq i8* %71, null
br i1 %72, label %104, label %73
73: ; preds = %68
%74 = getelementptr inbounds i8*, i8** %51, i64 1
br label %85
75: ; preds = %59
br i1 %64, label %76, label %78
76: ; preds = %75
%77 = tail call i32 @memset(i8* %62, i8 signext 0, i32 1)
br label %78
78: ; preds = %76, %75
%79 = tail call i32 @strlen(i8* %48)
%80 = add nsw i32 %79, 1
%81 = tail call i8* @malloc(i32 %80)
store i8* %81, i8** %52
%82 = icmp eq i8* %81, null
br i1 %82, label %104, label %83
83: ; preds = %78
%84 = getelementptr inbounds i8*, i8** %52, i64 1
br label %85
85: ; preds = %83, %73
%86 = phi i8* [ %81, %83 ], [ %71, %73 ]
%87 = phi i32 [ %80, %83 ], [ %70, %73 ]
%88 = phi i8** [ %51, %83 ], [ %74, %73 ]
%89 = phi i8** [ %84, %83 ], [ %52, %73 ]
%90 = ptrtoint i8* %86 to i64
%91 = trunc i64 %90 to i32
%92 = tail call i32 @strncpy(i32 %91, i8* %48, i32 %87)
%93 = xor i32 %53, 1
br label %96
94: ; preds = %57
%95 = getelementptr inbounds i8, i8* %55, i64 1
store i8 %50, i8* %55
br label %96
96: ; preds = %94, %85
%97 = phi i8** [ %88, %85 ], [ %51, %94 ]
%98 = phi i8** [ %89, %85 ], [ %52, %94 ]
%99 = phi i32 [ %93, %85 ], [ %53, %94 ]
%100 = phi i8* [ %48, %85 ], [ %95, %94 ]
%101 = load i8, i8* %56
br label %49
102: ; preds = %49
%103 = tail call i32 @free(i8* %12)
br label %104
104: ; preds = %78, %68, %44, %102, %14
%105 = phi i64 [ 0, %14 ], [ 0, %44 ], [ %33, %102 ], [ 0, %68 ], [ 0, %78 ]
ret i64 %105
}