#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*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
scalar_t__ fopen_with_error(char const *, char *, char const *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char const *, int);
int /*<<< orphan*/ free(char **);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
char *strclone(char *);
char *strrchr(char *, char);
char **read_strings(const char *fn, int *numlines) {
  const char *routine = "read_strings";
  char aline[512];
  char **values = 0;
  char **newvalues = 0;
  int i;
  int numread = 0;
  int numalloc = 0;
  FILE *fp;
  fp = (FILE *)fopen_with_error(fn, "r", routine);
  while (fgets(aline, 512, fp) != NULL) {
    if (numread == numalloc) {
      numalloc = 16 + 11 * numalloc / 10;
      newvalues = (char **)malloc(sizeof(char *) * numalloc);
      if (!newvalues)
        exit(fprintf(stderr, "%s: new char ** [%d] failed\n", routine,
                     numalloc));
      for (i = 0; i < numread; i++)
        newvalues[i] = values[i];
      for (i = numread; i < numalloc; i++)
        newvalues[i] = 0;
      if (values != NULL)
        free(values);
      values = newvalues;
    }
    {
      char *linereturn = strrchr(aline, '\n');
      if (linereturn)
        *linereturn = '\0';
    }
    values[numread++] = strclone(aline);
  }
  fclose(fp);
  *numlines = numread;
  return values;
}


x86 assembly (clang, -O0):
<read_strings>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xe56(%rip),%rax
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x228(%rbp)
movq   $0x0,-0x230(%rbp)
movl   $0x0,-0x238(%rbp)
movl   $0x0,-0x23c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    0xe26(%rip),%rsi
call   1080 <fopen_with_error@plt>
mov    %rax,-0x248(%rbp)
lea    -0x220(%rbp),%rdi
mov    -0x248(%rbp),%rdx
mov    $0x200,%esi
call   1060 <fgets@plt>
cmp    $0x0,%rax
je     13b3 <read_strings+0x223>
mov    -0x238(%rbp),%eax
cmp    -0x23c(%rbp),%eax
jne    1350 <read_strings+0x1c0>
imul   $0xb,-0x23c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x10,%eax
mov    %eax,-0x23c(%rbp)
movslq -0x23c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x230(%rbp)
cmpq   $0x0,-0x230(%rbp)
jne    128c <read_strings+0xfc>
mov    0x2d73(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rdx
mov    -0x23c(%rbp),%ecx
lea    0xd8f(%rip),%rsi
call   1070 <fprintf@plt>
mov    %eax,%edi
call   10a0 <exit@plt>
movl   $0x0,-0x234(%rbp)
mov    -0x234(%rbp),%eax
cmp    -0x238(%rbp),%eax
jge    12e0 <read_strings+0x150>
mov    -0x228(%rbp),%rax
movslq -0x234(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x230(%rbp),%rax
movslq -0x234(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    1296 <read_strings+0x106>
mov    -0x238(%rbp),%eax
mov    %eax,-0x234(%rbp)
mov    -0x234(%rbp),%eax
cmp    -0x23c(%rbp),%eax
jge    1328 <read_strings+0x198>
mov    -0x230(%rbp),%rax
movslq -0x234(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    12ec <read_strings+0x15c>
cmpq   $0x0,-0x228(%rbp)
je     1342 <read_strings+0x1b2>
mov    -0x228(%rbp),%rdi
call   1030 <free@plt>
mov    -0x230(%rbp),%rax
mov    %rax,-0x228(%rbp)
lea    -0x220(%rbp),%rdi
mov    $0xa,%esi
call   1050 <strrchr@plt>
mov    %rax,-0x250(%rbp)
cmpq   $0x0,-0x250(%rbp)
je     1380 <read_strings+0x1f0>
mov    -0x250(%rbp),%rax
movb   $0x0,(%rax)
lea    -0x220(%rbp),%rdi
call   10b0 <strclone@plt>
mov    %rax,%rdx
mov    -0x228(%rbp),%rax
mov    -0x238(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x238(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    11f3 <read_strings+0x63>
mov    -0x248(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x238(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x228(%rbp),%rax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_strings>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %rsi,%r15
lea    0xe52(%rip),%rsi
lea    0xe3e(%rip),%rdx
call   1090 <fopen_with_error@plt>
mov    %rax,%r12
lea    0x10(%rsp),%rdi
mov    $0x200,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     147b <read_strings+0x2db>
mov    %r15,0x8(%rsp)
xor    %r14d,%r14d
mov    $0xfffffffffffffffc,%r15
lea    0x10(%rsp),%rbp
xor    %ebx,%ebx
xor    %r13d,%r13d
mov    %r12,(%rsp)
jmp    123d <read_strings+0x9d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rdi
call   10c0 <strclone@plt>
mov    %rax,(%rbx,%r14,8)
add    $0x1,%r14
mov    %rbp,%rdi
mov    $0x200,%esi
mov    %r12,%rdx
call   1070 <fgets@plt>
add    $0x1,%r15
test   %rax,%rax
je     1474 <read_strings+0x2d4>
mov    %r13d,%eax
cmp    %rax,%r14
jne    1456 <read_strings+0x2b6>
lea    0x0(%r13,%r13,4),%eax
lea    0x0(%r13,%rax,2),%eax
cltq
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
lea    (%rax,%rcx,1),%r12d
lea    (%rax,%rcx,1),%r13d
add    $0x10,%r13d
lea    0x80(,%r12,8),%edi
call   10a0 <malloc@plt>
test   %rax,%rax
je     14a0 <read_strings+0x300>
mov    %rax,%rbp
test   %r14,%r14
je     1410 <read_strings+0x270>
cmp    $0x4,%r14
jb     12b8 <read_strings+0x118>
lea    (%rbx,%r14,8),%rax
cmp    %rax,%rbp
jae    1325 <read_strings+0x185>
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1325 <read_strings+0x185>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
test   $0x3,%r14b
je     12e3 <read_strings+0x143>
mov    %r14d,%edx
and    $0x3,%edx
nop
mov    (%rbx,%rax,8),%rsi
mov    %rsi,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12d0 <read_strings+0x130>
cmp    $0x3,%rcx
jb     1410 <read_strings+0x270>
nopl   (%rax)
mov    (%rbx,%rax,8),%rcx
mov    %rcx,0x0(%rbp,%rax,8)
mov    0x8(%rbx,%rax,8),%rcx
mov    %rcx,0x8(%rbp,%rax,8)
mov    0x10(%rbx,%rax,8),%rcx
mov    %rcx,0x10(%rbp,%rax,8)
mov    0x18(%rbx,%rax,8),%rcx
mov    %rcx,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    12f0 <read_strings+0x150>
jmp    1410 <read_strings+0x270>
mov    %r15,%rcx
shr    $0x2,%rcx
lea    -0x4(%r14),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    $0xc,%rax
jae    1345 <read_strings+0x1a5>
xor    %edx,%edx
jmp    13a9 <read_strings+0x209>
lea    0x1(%rcx),%rax
and    $0xfffffffffffffffc,%rax
xor    %edx,%edx
nop
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movups %xmm0,0x0(%rbp,%rdx,8)
movups %xmm1,0x10(%rbp,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm0
movups 0x30(%rbx,%rdx,8),%xmm1
movups %xmm0,0x20(%rbp,%rdx,8)
movups %xmm1,0x30(%rbp,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm0
movups 0x50(%rbx,%rdx,8),%xmm1
movups %xmm0,0x40(%rbp,%rdx,8)
movups %xmm1,0x50(%rbp,%rdx,8)
movups 0x60(%rbx,%rdx,8),%xmm0
movups 0x70(%rbx,%rdx,8),%xmm1
movups %xmm0,0x60(%rbp,%rdx,8)
movups %xmm1,0x70(%rbp,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rax
jne    1350 <read_strings+0x1b0>
mov    %r14,%rax
and    $0xfffffffffffffffc,%rax
test   $0x3,%sil
je     13fb <read_strings+0x25b>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x5,%rcx
lea    0x10(,%rdx,8),%rsi
add    %rbp,%rsi
lea    (%rbx,%rdx,8),%rdx
add    $0x10,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    13e0 <read_strings+0x240>
cmp    %rax,%r14
jne    12ba <read_strings+0x11a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %r13d,%rax
cmp    %rax,%r14
jge    143d <read_strings+0x29d>
mov    $0xf,%eax
sub    %r14d,%eax
lea    0x0(,%r14,8),%rdi
add    %rbp,%rdi
add    %eax,%r12d
lea    0x8(,%r12,8),%rdx
xor    %esi,%esi
call   1060 <memset@plt>
test   %rbx,%rbx
je     144a <read_strings+0x2aa>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rbx
mov    (%rsp),%r12
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
mov    $0xa,%esi
call   1050 <strrchr@plt>
test   %rax,%rax
je     1210 <read_strings+0x70>
movb   $0x0,(%rax)
jmp    1210 <read_strings+0x70>
mov    0x8(%rsp),%r15
jmp    1480 <read_strings+0x2e0>
xor    %r14d,%r14d
xor    %ebx,%ebx
mov    %r12,%rdi
call   1040 <fclose@plt>
mov    %r14d,(%r15)
mov    %rbx,%rax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2b39(%rip),%rax
mov    (%rax),%edi
lea    0xb5f(%rip),%rsi
lea    0xb49(%rip),%rdx
mov    %r13d,%ecx
call   1080 <fprintf@plt>
mov    %eax,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@.str = [13 x i8] c"read_strings\00"
@.str.1 = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.2 = [29 x i8] c"%s: new char ** [%d] failed\0A\00"
define i8** @read_strings(i8* %0, i32* %1) {
%3 = alloca i8*
%4 = alloca i32*
%5 = alloca i8*
%6 = alloca [512 x i8]
%7 = alloca i8**
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32*
%13 = alloca i8*
store i8* %0, i8** %3
store i32* %1, i32** %4
store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i8** %5
store i8** null, i8*** %7
store i8** null, i8*** %8
store i32 0, i32* %10
store i32 0, i32* %11
%14 = load i8*, i8** %3
%15 = load i8*, i8** %5
%16 = call i64 @fopen_with_error(i8* %14, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8* %15)
%17 = inttoptr i64 %16 to i32*
store i32* %17, i32** %12
br label %18
18: ; preds = %93, %2
%19 = getelementptr inbounds [512 x i8], [512 x i8]* %6, i64 0, i64 0
%20 = load i32*, i32** %12
%21 = call i32* @fgets(i8* %19, i32 512, i32* %20)
%22 = icmp ne i32* %21, null
br i1 %22, label %23, label %101
23: ; preds = %18
%24 = load i32, i32* %10
%25 = load i32, i32* %11
%26 = icmp eq i32 %24, %25
br i1 %26, label %27, label %86
27: ; preds = %23
%28 = load i32, i32* %11
%29 = mul nsw i32 11, %28
%30 = sdiv i32 %29, 10
%31 = add nsw i32 16, %30
store i32 %31, i32* %11
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = mul i64 8, %33
%35 = trunc i64 %34 to i32
%36 = call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to i8**
store i8** %37, i8*** %8
%38 = load i8**, i8*** %8
%39 = icmp ne i8** %38, null
br i1 %39, label %46, label %40
40: ; preds = %27
%41 = load i32, i32* @stderr
%42 = load i8*, i8** %5
%43 = load i32, i32* %11
%44 = call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %42, i32 %43)
%45 = call i32 @exit(i32 %44)
unreachable
46: ; preds = %27
store i32 0, i32* %9
br label %47
47: ; preds = %61, %46
%48 = load i32, i32* %9
%49 = load i32, i32* %10
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %64
51: ; preds = %47
%52 = load i8**, i8*** %7
%53 = load i32, i32* %9
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8*, i8** %52, i64 %54
%56 = load i8*, i8** %55
%57 = load i8**, i8*** %8
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8*, i8** %57, i64 %59
store i8* %56, i8** %60
br label %61
61: ; preds = %51
%62 = load i32, i32* %9
%63 = add nsw i32 %62, 1
store i32 %63, i32* %9
br label %47
64: ; preds = %47
%65 = load i32, i32* %10
store i32 %65, i32* %9
br label %66
66: ; preds = %75, %64
%67 = load i32, i32* %9
%68 = load i32, i32* %11
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %78
70: ; preds = %66
%71 = load i8**, i8*** %8
%72 = load i32, i32* %9
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8*, i8** %71, i64 %73
store i8* null, i8** %74
br label %75
75: ; preds = %70
%76 = load i32, i32* %9
%77 = add nsw i32 %76, 1
store i32 %77, i32* %9
br label %66
78: ; preds = %66
%79 = load i8**, i8*** %7
%80 = icmp ne i8** %79, null
br i1 %80, label %81, label %84
81: ; preds = %78
%82 = load i8**, i8*** %7
%83 = call i32 @free(i8** %82)
br label %84
84: ; preds = %81, %78
%85 = load i8**, i8*** %8
store i8** %85, i8*** %7
br label %86
86: ; preds = %84, %23
%87 = getelementptr inbounds [512 x i8], [512 x i8]* %6, i64 0, i64 0
%88 = call i8* @strrchr(i8* %87, i8 signext 10)
store i8* %88, i8** %13
%89 = load i8*, i8** %13
%90 = icmp ne i8* %89, null
br i1 %90, label %91, label %93
91: ; preds = %86
%92 = load i8*, i8** %13
store i8 0, i8* %92
br label %93
93: ; preds = %91, %86
%94 = getelementptr inbounds [512 x i8], [512 x i8]* %6, i64 0, i64 0
%95 = call i8* @strclone(i8* %94)
%96 = load i8**, i8*** %7
%97 = load i32, i32* %10
%98 = add nsw i32 %97, 1
store i32 %98, i32* %10
%99 = sext i32 %97 to i64
%100 = getelementptr inbounds i8*, i8** %96, i64 %99
store i8* %95, i8** %100
br label %18
101: ; preds = %18
%102 = load i32*, i32** %12
%103 = call i32 @fclose(i32* %102)
%104 = load i32, i32* %10
%105 = load i32*, i32** %4
store i32 %104, i32* %105
%106 = load i8**, i8*** %7
ret i8** %106
}

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