#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*/ O_RDONLY;
char **calloc(int, int);
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ memset(char *, char, size_t);
int open(char const *, int /*<<< orphan*/);
int read(int, char *, size_t);
char *realloc(char *, size_t);
int /*<<< orphan*/ stderr;
char **parse_proc_stringlist(const char *list) {
  int fd, n, i, n_strings;
  char *buf, *new_buf, **ret;
  size_t size, new_size, used;
  fd = open(list, O_RDONLY);
  if (fd == -1) {
    return NULL;
  }
  buf = NULL;
  size = 0;
  used = 0;
  for (;;) {
    new_size = used + 1024;
    new_buf = realloc(buf, new_size);
    if (new_buf == NULL) {
      free(buf);
      fprintf(stderr, "realloc(%ld): out of memory\n", (long)(size + 1024));
      return NULL;
    }
    buf = new_buf;
    size = new_size;
    memset(buf + used, '\0', size - used);
    n = read(fd, buf + used, size - used - 1);
    if (n < 0) {
      fprintf(stderr, "read(): %m\n");
      return NULL;
    }
    if (n == 0) {
      break;
    }
    used += n;
  }
  close(fd);
  n_strings = 0;
  for (n = 0; n < used; n++) {
    if ((n == 0) || (buf[n - 1] == '\0')) {
      n_strings++;
    }
  }
  ret = calloc(n_strings + 1, sizeof(char *));
  if (ret == NULL) {
    fprintf(stderr, "calloc(): out of memory\n");
    return NULL;
  }
  i = 0;
  for (n = 0; n < used; n++) {
    if ((n == 0) || (buf[n - 1] == '\0')) {
      ret[i++] = &buf[n];
    }
  }
  ret[i] = NULL;
  return ret;
}


x86 assembly (clang, -O0):
<parse_proc_stringlist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
mov    0x2e51(%rip),%rax
mov    (%rax),%esi
call   10a0 <open@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0xffffffff,-0x14(%rbp)
jne    11b8 <parse_proc_stringlist+0x38>
movq   $0x0,-0x8(%rbp)
jmp    13f9 <parse_proc_stringlist+0x279>
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
add    $0x400,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1090 <realloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1232 <parse_proc_stringlist+0xb2>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    0x2dce(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rdx
add    $0x400,%rdx
lea    0xde2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    13f9 <parse_proc_stringlist+0x279>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rdi
add    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rdx
sub    -0x50(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x14(%rbp),%edi
mov    -0x28(%rbp),%rsi
add    -0x50(%rbp),%rsi
mov    -0x40(%rbp),%rdx
sub    -0x50(%rbp),%rdx
sub    $0x1,%rdx
call   1060 <read@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jge    12a6 <parse_proc_stringlist+0x126>
mov    0x2d4f(%rip),%rax
mov    (%rax),%edi
lea    0xd8b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    13f9 <parse_proc_stringlist+0x279>
cmpl   $0x0,-0x18(%rbp)
jne    12b5 <parse_proc_stringlist+0x135>
jmp    12c6 <parse_proc_stringlist+0x146>
movslq -0x18(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    11d0 <parse_proc_stringlist+0x50>
mov    -0x14(%rbp),%edi
call   1050 <close@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
movslq -0x18(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    132a <parse_proc_stringlist+0x1aa>
cmpl   $0x0,-0x18(%rbp)
je     130e <parse_proc_stringlist+0x18e>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1317 <parse_proc_stringlist+0x197>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    131c <parse_proc_stringlist+0x19c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12dc <parse_proc_stringlist+0x15c>
mov    -0x20(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    136d <parse_proc_stringlist+0x1ed>
mov    0x2c88(%rip),%rax
mov    (%rax),%edi
lea    0xcd0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    13f9 <parse_proc_stringlist+0x279>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
movslq -0x18(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    13e1 <parse_proc_stringlist+0x261>
cmpl   $0x0,-0x18(%rbp)
je     13ad <parse_proc_stringlist+0x22d>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    13ce <parse_proc_stringlist+0x24e>
mov    -0x28(%rbp),%rdx
movslq -0x18(%rbp),%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    13d3 <parse_proc_stringlist+0x253>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    137b <parse_proc_stringlist+0x1fb>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_proc_stringlist>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x2e49(%rip),%rax
mov    (%rax),%esi
call   10b0 <open@plt>
cmp    $0xffffffff,%eax
je     1226 <parse_proc_stringlist+0x96>
mov    %eax,%r15d
mov    $0x400,%r12d
mov    $0x400,%edi
call   1090 <malloc@plt>
test   %rax,%rax
je     122e <parse_proc_stringlist+0x9e>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%r12
mov    %rax,%r14
lea    (%rax,%rbx,1),%rbp
mov    $0x400,%edx
mov    %rbp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    $0x3ff,%edx
mov    %r15d,%edi
mov    %rbp,%rsi
call   1060 <read@plt>
test   %eax,%eax
js     125b <parse_proc_stringlist+0xcb>
je     1270 <parse_proc_stringlist+0xe0>
mov    %eax,%eax
lea    (%r12,%rax,1),%rbx
lea    (%r12,%rax,1),%rsi
add    $0x400,%rsi
mov    %r14,%rdi
call   10a0 <realloc@plt>
test   %rax,%rax
jne    11d0 <parse_proc_stringlist+0x40>
add    $0x800,%r12
jmp    1231 <parse_proc_stringlist+0xa1>
xor    %r15d,%r15d
jmp    1513 <parse_proc_stringlist+0x383>
xor    %r14d,%r14d
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x2d98(%rip),%rax
mov    (%rax),%edi
lea    0xdd7(%rip),%rsi
xor    %r15d,%r15d
mov    %r12,%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    1513 <parse_proc_stringlist+0x383>
mov    0x2d76(%rip),%rax
mov    (%rax),%edi
lea    0xdd2(%rip),%rsi
jmp    1480 <parse_proc_stringlist+0x2f0>
mov    %r15d,%edi
call   1050 <close@plt>
test   %r12,%r12
je     12ab <parse_proc_stringlist+0x11b>
cmp    $0x1,%r12
jne    12cd <parse_proc_stringlist+0x13d>
mov    $0x2,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
test   %rax,%rax
je     1470 <parse_proc_stringlist+0x2e0>
mov    %rax,%r15
mov    %r14,(%rax)
mov    $0x1,%eax
jmp    1509 <parse_proc_stringlist+0x379>
mov    $0x1,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
test   %rax,%rax
je     1470 <parse_proc_stringlist+0x2e0>
mov    %rax,%r15
xor    %eax,%eax
jmp    1509 <parse_proc_stringlist+0x379>
lea    -0x1(%r12),%rbp
cmp    $0x8,%rbp
jae    12e7 <parse_proc_stringlist+0x157>
mov    $0x1,%edi
mov    $0x1,%eax
jmp    1420 <parse_proc_stringlist+0x290>
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     13a7 <parse_proc_stringlist+0x217>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm2,%xmm2
movdqa 0xce7(%rip),%xmm0
xor    %edx,%edx
movdqa 0xced(%rip),%xmm3
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   (%r14,%rdx,1),%xmm5
movd   0x4(%r14,%rdx,1),%xmm4
pcmpeqb %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm0,%xmm5
pcmpeqb %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%r14,%rdx,1),%xmm0
movd   0xc(%r14,%rdx,1),%xmm1
pcmpeqb %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm5,%xmm0
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1330 <parse_proc_stringlist+0x1a0>
jmp    13b5 <parse_proc_stringlist+0x225>
pxor   %xmm1,%xmm1
movdqa 0xc4d(%rip),%xmm0
xor    %edx,%edx
test   $0x1,%cl
je     13fb <parse_proc_stringlist+0x26b>
movd   (%r14,%rdx,1),%xmm2
movd   0x4(%r14,%rdx,1),%xmm3
pxor   %xmm4,%xmm4
pcmpeqb %xmm4,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movdqa 0xc31(%rip),%xmm5
pand   %xmm5,%xmm2
paddd  %xmm2,%xmm0
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm5,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %rax,%rbp
je     1432 <parse_proc_stringlist+0x2a2>
or     $0x1,%rax
xchg   %ax,%ax
cmpb   $0x1,-0x1(%r14,%rax,1)
adc    $0x0,%edi
add    $0x1,%rax
cmp    %rax,%r12
jne    1420 <parse_proc_stringlist+0x290>
add    $0x1,%edi
mov    $0x8,%esi
call   1070 <calloc@plt>
test   %rax,%rax
je     1470 <parse_proc_stringlist+0x2e0>
mov    %rax,%r15
test   %r12,%r12
je     148f <parse_proc_stringlist+0x2ff>
mov    %r14,(%r15)
mov    $0x1,%eax
cmp    $0x1,%r12
je     1509 <parse_proc_stringlist+0x379>
cmp    $0x2,%r12
jne    1493 <parse_proc_stringlist+0x303>
mov    $0x1,%eax
mov    $0x1,%ecx
jmp    14ee <parse_proc_stringlist+0x35e>
mov    0x2b61(%rip),%rax
mov    (%rax),%edi
lea    0xbc9(%rip),%rsi
xor    %r15d,%r15d
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    1513 <parse_proc_stringlist+0x383>
xor    %eax,%eax
jmp    1509 <parse_proc_stringlist+0x379>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x1(%r14),%rsi
lea    0x2(%r14),%rdi
mov    $0x1,%eax
mov    $0xffffffffffffffff,%rcx
jmp    14ca <parse_proc_stringlist+0x33a>
add    $0x2,%rsi
add    $0x2,%rdi
lea    (%rdx,%rcx,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rbx
je     14eb <parse_proc_stringlist+0x35b>
cmpb   $0x0,-0x1(%rsi)
jne    14da <parse_proc_stringlist+0x34a>
movslq %eax,%rbx
add    $0x1,%eax
mov    %rsi,(%r15,%rbx,8)
cmpb   $0x0,(%rsi)
jne    14b0 <parse_proc_stringlist+0x320>
movslq %eax,%rbx
add    $0x1,%eax
mov    %rdi,(%r15,%rbx,8)
jmp    14b0 <parse_proc_stringlist+0x320>
neg    %rcx
test   $0x1,%bpl
je     1509 <parse_proc_stringlist+0x379>
cmpb   $0x0,-0x1(%rcx,%r14,1)
jne    1509 <parse_proc_stringlist+0x379>
add    %rcx,%r14
movslq %eax,%rcx
add    $0x1,%eax
mov    %r14,(%r15,%rcx,8)
cltq
movq   $0x0,(%r15,%rax,8)
mov    %r15,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@O_RDONLY = global i32 0
@stderr = global i32 0
@.str = [29 x i8] c"realloc(%ld): out of memory\0A\00"
@.str.1 = [12 x i8] c"read(): %m\0A\00"
@.str.2 = [25 x i8] c"calloc(): out of memory\0A\00"
define i8** @parse_proc_stringlist(i8* %0) {
%2 = alloca i8**
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8**
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
store i8* %0, i8** %3
%14 = load i8*, i8** %3
%15 = load i32, i32* @O_RDONLY
%16 = call i32 @open(i8* %14, i32 %15)
store i32 %16, i32* %4
%17 = load i32, i32* %4
%18 = icmp eq i32 %17, -1
br i1 %18, label %19, label %20
19: ; preds = %1
store i8** null, i8*** %2
br label %143
20: ; preds = %1
store i8* null, i8** %8
store i64 0, i64* %11
store i64 0, i64* %13
br label %21
21: ; preds = %64, %20
%22 = load i64, i64* %13
%23 = add i64 %22, 1024
store i64 %23, i64* %12
%24 = load i8*, i8** %8
%25 = load i64, i64* %12
%26 = call i8* @realloc(i8* %24, i64 %25)
store i8* %26, i8** %9
%27 = load i8*, i8** %9
%28 = icmp eq i8* %27, null
br i1 %28, label %29, label %36
29: ; preds = %21
%30 = load i8*, i8** %8
%31 = call i32 @free(i8* %30)
%32 = load i32, i32* @stderr
%33 = load i64, i64* %11
%34 = add i64 %33, 1024
%35 = call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), i64 %34)
store i8** null, i8*** %2
br label %143
36: ; preds = %21
%37 = load i8*, i8** %9
store i8* %37, i8** %8
%38 = load i64, i64* %12
store i64 %38, i64* %11
%39 = load i8*, i8** %8
%40 = load i64, i64* %13
%41 = getelementptr inbounds i8, i8* %39, i64 %40
%42 = load i64, i64* %11
%43 = load i64, i64* %13
%44 = sub i64 %42, %43
%45 = call i32 @memset(i8* %41, i8 signext 0, i64 %44)
%46 = load i32, i32* %4
%47 = load i8*, i8** %8
%48 = load i64, i64* %13
%49 = getelementptr inbounds i8, i8* %47, i64 %48
%50 = load i64, i64* %11
%51 = load i64, i64* %13
%52 = sub i64 %50, %51
%53 = sub i64 %52, 1
%54 = call i32 @read(i32 %46, i8* %49, i64 %53)
store i32 %54, i32* %5
%55 = load i32, i32* %5
%56 = icmp slt i32 %55, 0
br i1 %56, label %57, label %60
57: ; preds = %36
%58 = load i32, i32* @stderr
%59 = call i32 (i32, i8*, ...) @fprintf(i32 %58, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0))
store i8** null, i8*** %2
br label %143
60: ; preds = %36
%61 = load i32, i32* %5
%62 = icmp eq i32 %61, 0
br i1 %62, label %63, label %64
63: ; preds = %60
br label %69
64: ; preds = %60
%65 = load i32, i32* %5
%66 = sext i32 %65 to i64
%67 = load i64, i64* %13
%68 = add i64 %67, %66
store i64 %68, i64* %13
br label %21
69: ; preds = %63
%70 = load i32, i32* %4
%71 = call i32 @close(i32 %70)
store i32 0, i32* %7
store i32 0, i32* %5
br label %72
72: ; preds = %93, %69
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = load i64, i64* %13
%76 = icmp ult i64 %74, %75
br i1 %76, label %77, label %96
77: ; preds = %72
%78 = load i32, i32* %5
%79 = icmp eq i32 %78, 0
br i1 %79, label %89, label %80
80: ; preds = %77
%81 = load i8*, i8** %8
%82 = load i32, i32* %5
%83 = sub nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %81, i64 %84
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %92
89: ; preds = %80, %77
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
store i32 %91, i32* %7
br label %92
92: ; preds = %89, %80
br label %93
93: ; preds = %92
%94 = load i32, i32* %5
%95 = add nsw i32 %94, 1
store i32 %95, i32* %5
br label %72
96: ; preds = %72
%97 = load i32, i32* %7
%98 = add nsw i32 %97, 1
%99 = call i8** @calloc(i32 %98, i32 8)
store i8** %99, i8*** %10
%100 = load i8**, i8*** %10
%101 = icmp eq i8** %100, null
br i1 %101, label %102, label %105
102: ; preds = %96
%103 = load i32, i32* @stderr
%104 = call i32 (i32, i8*, ...) @fprintf(i32 %103, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
store i8** null, i8*** %2
br label %143
105: ; preds = %96
store i32 0, i32* %6
store i32 0, i32* %5
br label %106
106: ; preds = %134, %105
%107 = load i32, i32* %5
%108 = sext i32 %107 to i64
%109 = load i64, i64* %13
%110 = icmp ult i64 %108, %109
br i1 %110, label %111, label %137
111: ; preds = %106
%112 = load i32, i32* %5
%113 = icmp eq i32 %112, 0
br i1 %113, label %123, label %114
114: ; preds = %111
%115 = load i8*, i8** %8
%116 = load i32, i32* %5
%117 = sub nsw i32 %116, 1
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %115, i64 %118
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %133
123: ; preds = %114, %111
%124 = load i8*, i8** %8
%125 = load i32, i32* %5
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %124, i64 %126
%128 = load i8**, i8*** %10
%129 = load i32, i32* %6
%130 = add nsw i32 %129, 1
store i32 %130, i32* %6
%131 = sext i32 %129 to i64
%132 = getelementptr inbounds i8*, i8** %128, i64 %131
store i8* %127, i8** %132
br label %133
133: ; preds = %123, %114
br label %134
134: ; preds = %133
%135 = load i32, i32* %5
%136 = add nsw i32 %135, 1
store i32 %136, i32* %5
br label %106
137: ; preds = %106
%138 = load i8**, i8*** %10
%139 = load i32, i32* %6
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8*, i8** %138, i64 %140
store i8* null, i8** %141
%142 = load i8**, i8*** %10
store i8** %142, i8*** %2
br label %143
143: ; preds = %137, %102, %57, %29, %19
%144 = load i8**, i8*** %2
ret i8** %144
}

LLVM IR (-O2):
@O_RDONLY = global i32 0
@stderr = global i32 0
@.str = [29 x i8] c"realloc(%ld): out of memory\0A\00"
@.str.1 = [12 x i8] c"read(): %m\0A\00"
@.str.2 = [25 x i8] c"calloc(): out of memory\0A\00"
define noalias i8** @parse_proc_stringlist(i8* nocapture %0) {
%2 = load i32, i32* @O_RDONLY
%3 = tail call i32 @open(i8* %0, i32 %2)
%4 = icmp eq i32 %3, -1
br i1 %4, label %197, label %5
5: ; preds = %1
%6 = tail call dereferenceable_or_null(1024) i8* @malloc(i64 1024)
%7 = icmp eq i8* %6, null
br i1 %7, label %10, label %16
8: ; preds = %28
%9 = add i64 %18, 2048
br label %10
10: ; preds = %8, %5
%11 = phi i8* [ %17, %8 ], [ null, %5 ]
%12 = phi i64 [ %9, %8 ], [ 1024, %5 ]
%13 = tail call i32 @free(i8* %11)
%14 = load i32, i32* @stderr
%15 = tail call i32 (i32, i8*, ...) @fprintf(i32 %14, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), i64 %12)
br label %197
16: ; preds = %5, %28
%17 = phi i8* [ %32, %28 ], [ %6, %5 ]
%18 = phi i64 [ %30, %28 ], [ 0, %5 ]
%19 = getelementptr inbounds i8, i8* %17, i64 %18
%20 = tail call i32 @memset(i8* %19, i8 signext 0, i64 1024)
%21 = tail call i32 @read(i32 %3, i8* %19, i64 1023)
%22 = icmp slt i32 %21, 0
br i1 %22, label %23, label %26
23: ; preds = %16
%24 = load i32, i32* @stderr
%25 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0))
br label %197
26: ; preds = %16
%27 = icmp eq i32 %21, 0
br i1 %27, label %34, label %28
28: ; preds = %26
%29 = zext i32 %21 to i64
%30 = add i64 %18, %29
%31 = add i64 %30, 1024
%32 = tail call i8* @realloc(i8* %17, i64 %31)
%33 = icmp eq i8* %32, null
br i1 %33, label %8, label %16
34: ; preds = %26
%35 = tail call i32 @close(i32 %3)
%36 = icmp eq i64 %18, 0
br i1 %36, label %130, label %37
37: ; preds = %34
%38 = icmp eq i64 %18, 1
br i1 %38, label %133, label %39
39: ; preds = %37
%40 = add i64 %18, -1
%41 = icmp ult i64 %40, 8
br i1 %41, label %111, label %42
42: ; preds = %39
%43 = and i64 %40, -8
%44 = or i64 %43, 1
%45 = add i64 %43, -8
%46 = lshr exact i64 %45, 3
%47 = add nuw nsw i64 %46, 1
%48 = and i64 %47, 1
%49 = icmp eq i64 %45, 0
br i1 %49, label %85, label %50
50: ; preds = %42
%51 = and i64 %47, 4611686018427387902
br label %52
52: ; preds = %52, %50
%53 = phi i64 [ 0, %50 ], [ %82, %52 ]
%54 = phi <4 x i32> [ <i32 1, i32 0, i32 0, i32 0>, %50 ], [ %80, %52 ]
%55 = phi <4 x i32> [ zeroinitializer, %50 ], [ %81, %52 ]
%56 = phi i64 [ 0, %50 ], [ %83, %52 ]
%57 = getelementptr inbounds i8, i8* %17, i64 %53
%58 = bitcast i8* %57 to <4 x i8>*
%59 = load <4 x i8>, <4 x i8>* %58
%60 = getelementptr inbounds i8, i8* %57, i64 4
%61 = bitcast i8* %60 to <4 x i8>*
%62 = load <4 x i8>, <4 x i8>* %61
%63 = icmp eq <4 x i8> %59, zeroinitializer
%64 = icmp eq <4 x i8> %62, zeroinitializer
%65 = zext <4 x i1> %63 to <4 x i32>
%66 = zext <4 x i1> %64 to <4 x i32>
%67 = add <4 x i32> %54, %65
%68 = add <4 x i32> %55, %66
%69 = or i64 %53, 8
%70 = getelementptr inbounds i8, i8* %17, i64 %69
%71 = bitcast i8* %70 to <4 x i8>*
%72 = load <4 x i8>, <4 x i8>* %71
%73 = getelementptr inbounds i8, i8* %70, i64 4
%74 = bitcast i8* %73 to <4 x i8>*
%75 = load <4 x i8>, <4 x i8>* %74
%76 = icmp eq <4 x i8> %72, zeroinitializer
%77 = icmp eq <4 x i8> %75, zeroinitializer
%78 = zext <4 x i1> %76 to <4 x i32>
%79 = zext <4 x i1> %77 to <4 x i32>
%80 = add <4 x i32> %67, %78
%81 = add <4 x i32> %68, %79
%82 = add nuw i64 %53, 16
%83 = add i64 %56, 2
%84 = icmp eq i64 %83, %51
br i1 %84, label %85, label %52
85: ; preds = %52, %42
%86 = phi <4 x i32> [ undef, %42 ], [ %80, %52 ]
%87 = phi <4 x i32> [ undef, %42 ], [ %81, %52 ]
%88 = phi i64 [ 0, %42 ], [ %82, %52 ]
%89 = phi <4 x i32> [ <i32 1, i32 0, i32 0, i32 0>, %42 ], [ %80, %52 ]
%90 = phi <4 x i32> [ zeroinitializer, %42 ], [ %81, %52 ]
%91 = icmp eq i64 %48, 0
br i1 %91, label %105, label %92
92: ; preds = %85
%93 = getelementptr inbounds i8, i8* %17, i64 %88
%94 = bitcast i8* %93 to <4 x i8>*
%95 = load <4 x i8>, <4 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 4
%97 = bitcast i8* %96 to <4 x i8>*
%98 = load <4 x i8>, <4 x i8>* %97
%99 = icmp eq <4 x i8> %95, zeroinitializer
%100 = icmp eq <4 x i8> %98, zeroinitializer
%101 = zext <4 x i1> %99 to <4 x i32>
%102 = zext <4 x i1> %100 to <4 x i32>
%103 = add <4 x i32> %89, %101
%104 = add <4 x i32> %90, %102
br label %105
105: ; preds = %85, %92
%106 = phi <4 x i32> [ %86, %85 ], [ %103, %92 ]
%107 = phi <4 x i32> [ %87, %85 ], [ %104, %92 ]
%108 = add <4 x i32> %107, %106
%109 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %108)
%110 = icmp eq i64 %40, %43
br i1 %110, label %125, label %111
111: ; preds = %39, %105
%112 = phi i64 [ 1, %39 ], [ %44, %105 ]
%113 = phi i32 [ 1, %39 ], [ %109, %105 ]
br label %114
114: ; preds = %111, %114
%115 = phi i64 [ %123, %114 ], [ %112, %111 ]
%116 = phi i32 [ %122, %114 ], [ %113, %111 ]
%117 = add nsw i64 %115, -1
%118 = getelementptr inbounds i8, i8* %17, i64 %117
%119 = load i8, i8* %118
%120 = icmp eq i8 %119, 0
%121 = zext i1 %120 to i32
%122 = add nuw nsw i32 %116, %121
%123 = add nuw nsw i64 %115, 1
%124 = icmp eq i64 %123, %18
br i1 %124, label %125, label %114
125: ; preds = %114, %105
%126 = phi i32 [ %109, %105 ], [ %122, %114 ]
%127 = add nuw nsw i32 %126, 1
%128 = tail call i8** @calloc(i32 %127, i32 8)
%129 = icmp eq i8** %128, null
br i1 %129, label %145, label %137
130: ; preds = %34
%131 = tail call i8** @calloc(i32 1, i32 8)
%132 = icmp eq i8** %131, null
br i1 %132, label %145, label %192
133: ; preds = %37
%134 = tail call i8** @calloc(i32 2, i32 8)
%135 = icmp eq i8** %134, null
br i1 %135, label %145, label %136
136: ; preds = %133
store i8* %17, i8** %134
br label %192
137: ; preds = %125
br i1 %36, label %192, label %138
138: ; preds = %137
store i8* %17, i8** %128
%139 = icmp eq i64 %18, 1
br i1 %139, label %192, label %140
140: ; preds = %138
%141 = and i64 %40, 1
%142 = icmp eq i64 %18, 2
br i1 %142, label %177, label %143
143: ; preds = %140
%144 = and i64 %40, -2
br label %148
145: ; preds = %130, %133, %125
%146 = load i32, i32* @stderr
%147 = tail call i32 (i32, i8*, ...) @fprintf(i32 %146, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
br label %197
148: ; preds = %172, %143
%149 = phi i64 [ 1, %143 ], [ %174, %172 ]
%150 = phi i32 [ 1, %143 ], [ %173, %172 ]
%151 = phi i64 [ 0, %143 ], [ %175, %172 ]
%152 = add nsw i64 %149, -1
%153 = getelementptr inbounds i8, i8* %17, i64 %152
%154 = load i8, i8* %153
%155 = icmp eq i8 %154, 0
br i1 %155, label %156, label %161
156: ; preds = %148
%157 = getelementptr inbounds i8, i8* %17, i64 %149
%158 = add nsw i32 %150, 1
%159 = sext i32 %150 to i64
%160 = getelementptr inbounds i8*, i8** %128, i64 %159
store i8* %157, i8** %160
br label %161
161: ; preds = %148, %156
%162 = phi i32 [ %158, %156 ], [ %150, %148 ]
%163 = getelementptr inbounds i8, i8* %17, i64 %149
%164 = load i8, i8* %163
%165 = icmp eq i8 %164, 0
br i1 %165, label %166, label %172
166: ; preds = %161
%167 = add nuw nsw i64 %149, 1
%168 = getelementptr inbounds i8, i8* %17, i64 %167
%169 = add nsw i32 %162, 1
%170 = sext i32 %162 to i64
%171 = getelementptr inbounds i8*, i8** %128, i64 %170
store i8* %168, i8** %171
br label %172
172: ; preds = %166, %161
%173 = phi i32 [ %169, %166 ], [ %162, %161 ]
%174 = add nuw nsw i64 %149, 2
%175 = add i64 %151, 2
%176 = icmp eq i64 %175, %144
br i1 %176, label %177, label %148
177: ; preds = %172, %140
%178 = phi i32 [ undef, %140 ], [ %173, %172 ]
%179 = phi i64 [ 1, %140 ], [ %174, %172 ]
%180 = phi i32 [ 1, %140 ], [ %173, %172 ]
%181 = icmp eq i64 %141, 0
br i1 %181, label %192, label %182
182: ; preds = %177
%183 = add nsw i64 %179, -1
%184 = getelementptr inbounds i8, i8* %17, i64 %183
%185 = load i8, i8* %184
%186 = icmp eq i8 %185, 0
br i1 %186, label %187, label %192
187: ; preds = %182
%188 = getelementptr inbounds i8, i8* %17, i64 %179
%189 = add nsw i32 %180, 1
%190 = sext i32 %180 to i64
%191 = getelementptr inbounds i8*, i8** %128, i64 %190
store i8* %188, i8** %191
br label %192
192: ; preds = %177, %187, %182, %130, %138, %136, %137
%193 = phi i8** [ %128, %137 ], [ %128, %138 ], [ %134, %136 ], [ %131, %130 ], [ %128, %182 ], [ %128, %187 ], [ %128, %177 ]
%194 = phi i32 [ 0, %137 ], [ 1, %138 ], [ 1, %136 ], [ 0, %130 ], [ %178, %177 ], [ %189, %187 ], [ %180, %182 ]
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i8*, i8** %193, i64 %195
store i8* null, i8** %196
br label %197
197: ; preds = %1, %192, %145, %23, %10
%198 = phi i8** [ null, %10 ], [ null, %23 ], [ null, %145 ], [ %193, %192 ], [ null, %1 ]
ret i8** %198
}