#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;
char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int, int /*<<< orphan*/);
int ftell(int /*<<< orphan*/ *);
char *malloc(int);
int /*<<< orphan*/ printf(char *, char *);
int /*<<< orphan*/ strcat(char *, char);
scalar_t__ strstr(char *, char *);
void readfileinreverse(FILE *fp) {
  int i, size, start, loop, counter;
  char *buffer;
  char line[256];
  start = 0;
  fseek(fp, 0, SEEK_END);
  size = ftell(fp);
  buffer = malloc((size + 1) * sizeof(char));
  for (i = 0; i < size; i++) {
    fseek(fp, size - 1 - i, SEEK_SET);
    buffer[i] = fgetc(fp);
    if (buffer[i] == 10) {
      if (i != 0) {
        counter = 0;
        for (loop = i; loop > start; loop--) {
          if ((counter == 0) && (buffer[loop] == 10)) {
            continue;
          }
          line[counter] = buffer[loop];
          counter++;
        }
        line[counter] = 0;
        start = i;
        printf("%s\n", line);
      }
    }
  }
  if (i > start) {
    counter = 0;
    for (loop = i; loop > start; loop--) {
      if ((counter == 0) && ((buffer[loop] == 10) || (buffer[loop] == 0))) {
        continue;
      }
      line[counter] = buffer[loop];
      counter++;
    }
    line[counter] = 0;
    char buf[100];
    strcat(buf, line[counter]);
    if (strstr(buf, "2017-03-23")) {
      printf("%s\n", line);
    }
    return;
  }
}


x86 assembly (clang, -O0):
<readfileinreverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
mov    0x2e57(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   1070 <fseek@plt>
mov    -0x8(%rbp),%rdi
call   1050 <ftell@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12c7 <readfileinreverse+0x157>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%esi
sub    $0x1,%esi
sub    -0xc(%rbp),%esi
mov    0x2df4(%rip),%rax
mov    (%rax),%edx
call   1070 <fseek@plt>
mov    -0x8(%rbp),%rdi
call   1040 <fgetc@plt>
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    12b4 <readfileinreverse+0x144>
cmpl   $0x0,-0xc(%rbp)
je     12af <readfileinreverse+0x13f>
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    128a <readfileinreverse+0x11a>
cmpl   $0x0,-0x1c(%rbp)
jne    125d <readfileinreverse+0xed>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    125d <readfileinreverse+0xed>
jmp    127c <readfileinreverse+0x10c>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    122d <readfileinreverse+0xbd>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
lea    -0x130(%rbp),%rsi
lea    0xd56(%rip),%rdi
call   1030 <printf@plt>
jmp    12b4 <readfileinreverse+0x144>
jmp    12b9 <readfileinreverse+0x149>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11c4 <readfileinreverse+0x54>
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    13ab <readfileinreverse+0x23b>
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1352 <readfileinreverse+0x1e2>
cmpl   $0x0,-0x1c(%rbp)
jne    1325 <readfileinreverse+0x1b5>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     1320 <readfileinreverse+0x1b0>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1325 <readfileinreverse+0x1b5>
jmp    1344 <readfileinreverse+0x1d4>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12e0 <readfileinreverse+0x170>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x1a0(%rbp),%rdi
movslq -0x1c(%rbp),%rax
movsbl -0x130(%rbp,%rax,1),%esi
ff
call   1080 <strcat@plt>
lea    -0x1a0(%rbp),%rdi
lea    0xc80(%rip),%rsi
call   1090 <strstr@plt>
cmp    $0x0,%rax
je     13a6 <readfileinreverse+0x236>
lea    -0x130(%rbp),%rsi
lea    0xc5f(%rip),%rdi
call   1030 <printf@plt>
jmp    13ab <readfileinreverse+0x23b>
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readfileinreverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %rdi,%rbx
mov    0x2e5d(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   1070 <fseek@plt>
mov    %rbx,0x10(%rsp)
mov    %rbx,%rdi
call   1050 <ftell@plt>
mov    %eax,%ebp
lea    0x1(%rbp),%edi
call   1060 <malloc@plt>
mov    %rax,(%rsp)
xor    %eax,%eax
test   %ebp,%ebp
jle    137f <readfileinreverse+0x20f>
mov    %ebp,%edi
mov    (%rsp),%r14
xor    %r13d,%r13d
xor    %r12d,%r12d
mov    %rdi,0x8(%rsp)
jmp    11ef <readfileinreverse+0x7f>
nopl   0x0(%rax)
mov    %ebx,%eax
mov    0x8(%rsp),%rdi
mov    %r15,%rbp
add    $0x1,%r12
add    $0xffffffffffffffff,%r13
add    $0x1,%r14
cmp    %rdi,%r12
je     1308 <readfileinreverse+0x198>
mov    %eax,%ebx
mov    %r12d,%eax
mov    %rax,0x18(%rsp)
mov    %eax,%esi
not    %esi
mov    %rbp,%r15
add    %ebp,%esi
mov    0x2dcf(%rip),%rax
mov    (%rax),%edx
mov    0x10(%rsp),%rbp
mov    %rbp,%rdi
call   1070 <fseek@plt>
mov    %rbp,%rdi
call   1040 <fgetc@plt>
mov    (%rsp),%rcx
mov    %al,(%rcx,%r12,1)
cmp    $0xa,%al
jne    11d0 <readfileinreverse+0x60>
test   %r12,%r12
je     11d0 <readfileinreverse+0x60>
movslq %ebx,%rdi
xor    %esi,%esi
mov    %r12,%rax
sub    %rdi,%rax
mov    %r15,%rbp
jle    12e0 <readfileinreverse+0x170>
add    $0x1,%rdi
xor    %ecx,%ecx
mov    %r12,%rdx
cmp    %rdi,%r12
je     12ba <readfileinreverse+0x14a>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xor    %edx,%edx
xor    %ecx,%ecx
jmp    1285 <readfileinreverse+0x115>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %edi,%rcx
mov    %bl,0x20(%rsp,%rcx,1)
add    $0x1,%edi
mov    %edi,%ecx
add    $0xfffffffffffffffe,%rdx
cmp    %rdx,%rsi
je     12b7 <readfileinreverse+0x147>
movzbl (%r14,%rdx,1),%ebx
test   %ecx,%ecx
jne    1298 <readfileinreverse+0x128>
mov    $0x0,%edi
cmp    $0xa,%bl
je     12a4 <readfileinreverse+0x134>
movslq %ecx,%rdi
mov    %bl,0x20(%rsp,%rdi,1)
add    $0x1,%ecx
mov    %ecx,%edi
movzbl -0x1(%r14,%rdx,1),%ebx
test   %edi,%edi
jne    1270 <readfileinreverse+0x100>
xor    %ecx,%ecx
cmp    $0xa,%bl
je     127c <readfileinreverse+0x10c>
jmp    1270 <readfileinreverse+0x100>
sub    %r13,%rdx
mov    %ecx,%esi
test   $0x1,%al
je     12e0 <readfileinreverse+0x170>
mov    (%rsp),%rax
mov    (%rax,%rdx,1),%al
test   %ecx,%ecx
jne    12d1 <readfileinreverse+0x161>
xor    %esi,%esi
cmp    $0xa,%al
je     12e0 <readfileinreverse+0x170>
movslq %ecx,%rdx
mov    %al,0x20(%rsp,%rdx,1)
add    $0x1,%ecx
mov    %ecx,%esi
nopl   (%rax)
movslq %esi,%rax
movb   $0x0,0x20(%rsp,%rax,1)
lea    0xd11(%rip),%rdi
lea    0x20(%rsp),%rsi
call   1030 <printf@plt>
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rax
jmp    11da <readfileinreverse+0x6a>
cmp    %eax,%ebp
jle    137f <readfileinreverse+0x20f>
movslq %eax,%rcx
mov    %rdi,%rax
sub    %rcx,%rax
not    %rcx
add    %rdi,%rcx
jne    1391 <readfileinreverse+0x221>
xor    %ecx,%ecx
mov    %ecx,%edx
test   $0x1,%al
je     1340 <readfileinreverse+0x1d0>
mov    (%rsp),%rax
mov    (%rax,%rdi,1),%al
test   %ecx,%ecx
je     13fd <readfileinreverse+0x28d>
movslq %ecx,%rdx
mov    %al,0x20(%rsp,%rdx,1)
add    $0x1,%ecx
mov    %ecx,%edx
movslq %edx,%rax
movb   $0x0,0x20(%rsp,%rax,1)
lea    0x120(%rsp),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
call   1080 <strcat@plt>
lea    0xca3(%rip),%rsi
mov    %rbx,%rdi
call   1090 <strstr@plt>
test   %rax,%rax
je     137f <readfileinreverse+0x20f>
lea    0xc8b(%rip),%rdi
lea    0x20(%rsp),%rsi
call   1030 <printf@plt>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
jmp    13ba <readfileinreverse+0x24a>
nopl   0x0(%rax)
movslq %esi,%rcx
mov    %bl,0x20(%rsp,%rcx,1)
add    $0x1,%esi
mov    %esi,%ecx
add    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffffe,%rdx
je     131f <readfileinreverse+0x1af>
mov    (%rsp),%rsi
movzbl (%rsi,%rdi,1),%ebx
test   %ecx,%ecx
je     13f0 <readfileinreverse+0x280>
movslq %ecx,%rsi
mov    %bl,0x20(%rsp,%rsi,1)
add    $0x1,%ecx
mov    %ecx,%esi
mov    (%rsp),%rcx
movzbl -0x1(%rcx,%rdi,1),%ebx
test   %esi,%esi
jne    13a0 <readfileinreverse+0x230>
xor    %ecx,%ecx
test   %bl,%bl
je     13ac <readfileinreverse+0x23c>
cmp    $0xa,%bl
je     13ac <readfileinreverse+0x23c>
jmp    13a0 <readfileinreverse+0x230>
nopl   0x0(%rax)
xor    %esi,%esi
test   %bl,%bl
je     13d2 <readfileinreverse+0x262>
cmp    $0xa,%bl
je     13d2 <readfileinreverse+0x262>
jmp    13c6 <readfileinreverse+0x256>
xor    %edx,%edx
test   %al,%al
je     1340 <readfileinreverse+0x1d0>
cmp    $0xa,%al
je     1340 <readfileinreverse+0x1d0>
jmp    1334 <readfileinreverse+0x1c4>

LLVM IR (-O0):
@SEEK_END = global i32 0
@SEEK_SET = global i32 0
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [11 x i8] c"2017-03-23\00"
define void @readfileinreverse(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca [256 x i8]
%10 = alloca [100 x i8]
store i32* %0, i32** %2
store i32 0, i32* %5
%11 = load i32*, i32** %2
%12 = load i32, i32* @SEEK_END
%13 = call i32 @fseek(i32* %11, i32 0, i32 %12)
%14 = load i32*, i32** %2
%15 = call i32 @ftell(i32* %14)
store i32 %15, i32* %4
%16 = load i32, i32* %4
%17 = add nsw i32 %16, 1
%18 = sext i32 %17 to i64
%19 = mul i64 %18, 1
%20 = trunc i64 %19 to i32
%21 = call i8* @malloc(i32 %20)
store i8* %21, i8** %8
store i32 0, i32* %3
br label %22
22: ; preds = %91, %1
%23 = load i32, i32* %3
%24 = load i32, i32* %4
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %94
26: ; preds = %22
%27 = load i32*, i32** %2
%28 = load i32, i32* %4
%29 = sub nsw i32 %28, 1
%30 = load i32, i32* %3
%31 = sub nsw i32 %29, %30
%32 = load i32, i32* @SEEK_SET
%33 = call i32 @fseek(i32* %27, i32 %31, i32 %32)
%34 = load i32*, i32** %2
%35 = call signext i8 @fgetc(i32* %34)
%36 = load i8*, i8** %8
%37 = load i32, i32* %3
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
store i8 %35, i8* %39
%40 = load i8*, i8** %8
%41 = load i32, i32* %3
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 10
br i1 %46, label %47, label %90
47: ; preds = %26
%48 = load i32, i32* %3
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %89
50: ; preds = %47
store i32 0, i32* %7
%51 = load i32, i32* %3
store i32 %51, i32* %6
br label %52
52: ; preds = %79, %50
%53 = load i32, i32* %6
%54 = load i32, i32* %5
%55 = icmp sgt i32 %53, %54
br i1 %55, label %56, label %82
56: ; preds = %52
%57 = load i32, i32* %7
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %68
59: ; preds = %56
%60 = load i8*, i8** %8
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp eq i32 %65, 10
br i1 %66, label %67, label %68
67: ; preds = %59
br label %79
68: ; preds = %59, %56
%69 = load i8*, i8** %8
%70 = load i32, i32* %6
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8, i8* %72
%74 = load i32, i32* %7
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %75
store i8 %73, i8* %76
%77 = load i32, i32* %7
%78 = add nsw i32 %77, 1
store i32 %78, i32* %7
br label %79
79: ; preds = %68, %67
%80 = load i32, i32* %6
%81 = add nsw i32 %80, -1
store i32 %81, i32* %6
br label %52
82: ; preds = %52
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %84
store i8 0, i8* %85
%86 = load i32, i32* %3
store i32 %86, i32* %5
%87 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%88 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %87)
br label %89
89: ; preds = %82, %47
br label %90
90: ; preds = %89, %26
br label %91
91: ; preds = %90
%92 = load i32, i32* %3
%93 = add nsw i32 %92, 1
store i32 %93, i32* %3
br label %22
94: ; preds = %22
%95 = load i32, i32* %3
%96 = load i32, i32* %5
%97 = icmp sgt i32 %95, %96
br i1 %97, label %98, label %155
98: ; preds = %94
store i32 0, i32* %7
%99 = load i32, i32* %3
store i32 %99, i32* %6
br label %100
100: ; preds = %135, %98
%101 = load i32, i32* %6
%102 = load i32, i32* %5
%103 = icmp sgt i32 %101, %102
br i1 %103, label %104, label %138
104: ; preds = %100
%105 = load i32, i32* %7
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %124
107: ; preds = %104
%108 = load i8*, i8** %8
%109 = load i32, i32* %6
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %108, i64 %110
%112 = load i8, i8* %111
%113 = sext i8 %112 to i32
%114 = icmp eq i32 %113, 10
br i1 %114, label %123, label %115
115: ; preds = %107
%116 = load i8*, i8** %8
%117 = load i32, i32* %6
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %116, 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 %124
123: ; preds = %115, %107
br label %135
124: ; preds = %115, %104
%125 = load i8*, i8** %8
%126 = load i32, i32* %6
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %125, i64 %127
%129 = load i8, i8* %128
%130 = load i32, i32* %7
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %131
store i8 %129, i8* %132
%133 = load i32, i32* %7
%134 = add nsw i32 %133, 1
store i32 %134, i32* %7
br label %135
135: ; preds = %124, %123
%136 = load i32, i32* %6
%137 = add nsw i32 %136, -1
store i32 %137, i32* %6
br label %100
138: ; preds = %100
%139 = load i32, i32* %7
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %140
store i8 0, i8* %141
%142 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%143 = load i32, i32* %7
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %144
%146 = load i8, i8* %145
%147 = call i32 @strcat(i8* %142, i8 signext %146)
%148 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%149 = call i64 @strstr(i8* %148, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%150 = icmp ne i64 %149, 0
br i1 %150, label %151, label %154
151: ; preds = %138
%152 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%153 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %152)
br label %154
154: ; preds = %151, %138
br label %155
155: ; preds = %154, %94
ret void
}

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