#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*/ freopen(char *, char *, int /*<<< orphan*/);
scalar_t__ gets(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stdin;
int strlen(char *);
int main() {
  freopen("In572.txt", "r", stdin);
  int i = 0, j, k, n, len, biglen = 0, sen;
  char str[150], arr[150][150] = {'\0'};
  char str2[150][150];
  while (gets(str)) {
    len = strlen(str);
    if (len > biglen)
      biglen = len;
    for (j = 0; j <= len; j++) {
      arr[j][i] = str[j];
    }
    i++;
  }
  sen = i - 1;
  for (k = 0; k < biglen; k++) {
    for (j = sen; j >= 0; j--) {
      str2[k][sen - j] = arr[k][j];
    }
  }
  arr[k][j] = '\0';
  for (k = 0; k < biglen; k++) {
    for (j = 0; str2[k][j] != '\0'; j++) {
      printf("%c", str2[k][j]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0a0,%rsp
movl   $0x0,-0x4(%rbp)
mov    0x2e7f(%rip),%rax
mov    (%rax),%edx
lea    0xe8e(%rip),%rdi
lea    0xe91(%rip),%rsi
call   1060 <freopen@plt>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    -0x58b0(%rbp),%rdi
xor    %esi,%esi
mov    $0x57e4,%edx
call   1050 <memset@plt>
lea    -0xc0(%rbp),%rdi
call   1070 <gets@plt>
cmp    $0x0,%rax
je     122c <main+0xdc>
lea    -0xc0(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    11d6 <main+0x86>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     121e <main+0xce>
movslq -0xc(%rbp),%rax
mov    -0xc0(%rbp,%rax,1),%dl
movslq -0xc(%rbp),%rcx
lea    -0x58b0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11dd <main+0x8d>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    119f <main+0x4f>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12b6 <main+0x166>
mov    -0x20(%rbp),%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     12a3 <main+0x153>
movslq -0x10(%rbp),%rcx
lea    -0x58b0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x10(%rbp),%rcx
lea    -0xb0a0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    124e <main+0xfe>
jmp    12a8 <main+0x158>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    123c <main+0xec>
movslq -0x10(%rbp),%rcx
lea    -0x58b0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1368 <main+0x218>
movl   $0x0,-0xc(%rbp)
movslq -0x10(%rbp),%rcx
lea    -0xb0a0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     134c <main+0x1fc>
movslq -0x10(%rbp),%rcx
lea    -0xb0a0(%rbp),%rax
imul   $0x96,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xcd5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12ed <main+0x19d>
lea    0xcbc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12da <main+0x18a>
xor    %eax,%eax
add    $0xb0a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb098,%rsp
mov    0x2e80(%rip),%rax
mov    (%rax),%edx
lea    0xe8f(%rip),%rdi
lea    0xe92(%rip),%rsi
call   1060 <freopen@plt>
lea    0xc0(%rsp),%r15
xor    %ebx,%ebx
mov    $0x57e4,%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x20(%rsp),%rdi
call   1070 <gets@plt>
test   %rax,%rax
je     143a <main+0x2ea>
mov    $0x1,%ecx
lea    0x20(%rsp),%rdi
xor    %r13d,%r13d
jmp    11e9 <main+0x99>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
mov    %r13,%r12
add    $0x1,%r13
mov    %r14,%rdi
call   1070 <gets@plt>
mov    %r14,%rdi
mov    0x18(%rsp),%rdx
lea    0x1(%rdx),%ecx
add    $0x1,%r15
test   %rax,%rax
je     12ae <main+0x15e>
mov    %ecx,%eax
mov    %rax,0x18(%rsp)
mov    %rdi,%r14
call   1040 <strlen@plt>
cmp    %ebx,%eax
cmovg  %eax,%ebx
test   %eax,%eax
js     11c0 <main+0x70>
mov    %eax,%ebp
mov    %eax,%ecx
add    $0x1,%rcx
mov    %ecx,%eax
and    $0x3,%eax
mov    %rbx,%rdi
cmp    $0x3,%ebp
jae    1220 <main+0xd0>
xor    %edx,%edx
jmp    1268 <main+0x118>
nopw   0x0(%rax,%rax,1)
and    $0xfffffffc,%ecx
mov    %r15,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl 0x20(%rsp,%rdx,1),%ebx
mov    %bl,(%rsi)
movzbl 0x21(%rsp,%rdx,1),%ebx
mov    %bl,0x96(%rsi)
movzbl 0x22(%rsp,%rdx,1),%ebx
mov    %bl,0x12c(%rsi)
movzbl 0x23(%rsp,%rdx,1),%ebx
mov    %bl,0x1c2(%rsi)
add    $0x4,%rdx
add    $0x258,%rsi
cmp    %rdx,%rcx
jne    1230 <main+0xe0>
add    $0x1,%ebp
test   %rax,%rax
je     12a6 <main+0x156>
imul   $0x96,%rdx,%rcx
add    %r15,%rcx
add    %rsp,%rdx
add    $0x20,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%rcx)
add    $0x1,%rsi
add    $0x96,%rcx
cmp    %rsi,%rax
jne    1290 <main+0x140>
mov    %rdi,%rbx
jmp    11c2 <main+0x72>
test   %ebx,%ebx
jle    143a <main+0x2ea>
mov    %r12,%rdi
lea    -0x1(%r13),%r8d
mov    %r13,%r11
shl    $0x20,%r11
movslq %r13d,%rax
lea    -0x1(%rax),%r10
mov    %rbx,0x8(%rsp)
mov    %ebx,%r12d
mov    %r13d,%ecx
and    $0x1f,%ecx
mov    %rcx,%r15
sub    %rax,%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
movslq %edx,%rsi
and    $0x1f,%edx
lea    (%rsp,%rsi,1),%r9
add    $0xb0,%r9
movslq %edi,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x58b0,%rdi
sub    %rsi,%rax
sub    %rdx,%rsi
lea    (%rsp,%rax,1),%rdx
add    $0x58c1,%rdx
lea    0xc0(%rsp),%rcx
xor    %r14d,%r14d
shr    $0x25,%r11
pxor   %xmm0,%xmm0
jmp    1359 <main+0x209>
add    $0x1,%r14
add    $0x96,%r9
add    $0x96,%rdx
add    $0x96,%rdi
add    $0x96,%rcx
cmp    %r12,%r14
je     1447 <main+0x2f7>
mov    %r8d,%ebx
test   %r13d,%r13d
jle    1330 <main+0x1e0>
mov    %r10,%rbx
test   %r11,%r11
je     140b <main+0x2bb>
mov    %r9,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rbx),%xmm1
movdqu (%rbx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rdx,%rbp,1)
movdqu %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffe0,%rbx
cmp    %rbp,%rsi
jne    1380 <main+0x230>
mov    0x10(%rsp),%rbx
test   %r15,%r15
je     1330 <main+0x1e0>
lea    0x1(%rbx),%rbp
neg    %rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x1(%rcx,%rbp,1),%eax
mov    %al,(%rdi,%rbx,1)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jg     1420 <main+0x2d0>
neg    %rbx
jmp    1330 <main+0x1e0>
movslq %ebp,%rax
movb   $0x0,0xc0(%rsp,%rax,1)
jmp    14c5 <main+0x375>
imul   $0x96,%r12,%rax
movslq %ebx,%rcx
add    %rsp,%rax
add    $0xc0,%rax
movb   $0x0,(%rcx,%rax,1)
cmpl   $0x0,0x8(%rsp)
jle    14c5 <main+0x375>
lea    0x58b1(%rsp),%r14
xor    %ebp,%ebp
jmp    149a <main+0x34a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
add    $0x96,%r14
cmp    %r12,%rbp
je     14c5 <main+0x375>
imul   $0x96,%rbp,%rax
mov    0x58b0(%rsp,%rax,1),%al
test   %al,%al
je     1480 <main+0x330>
mov    %r14,%rbx
nop
movsbl %al,%edi
call   1030 <putchar@plt>
movzbl (%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    14b0 <main+0x360>
jmp    1480 <main+0x330>
xor    %eax,%eax
add    $0xb098,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [10 x i8] c"In572.txt\00"
@.str.1 = [2 x i8] c"r\00"
@stdin = global i32 0
@.str.2 = [3 x i8] c"%c\00"
@.str.3 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [150 x i8]
%10 = alloca [150 x [150 x i8]]
%11 = alloca [150 x [150 x i8]]
store i32 0, i32* %1
%12 = load i32, i32* @stdin
%13 = call i32 @freopen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %12)
store i32 0, i32* %2
store i32 0, i32* %7
%14 = bitcast [150 x [150 x i8]]* %10 to i8*
br label %15
15: ; preds = %46, %0
%16 = getelementptr inbounds [150 x i8], [150 x i8]* %9, i64 0, i64 0
%17 = call i64 @gets(i8* %16)
%18 = icmp ne i64 %17, 0
br i1 %18, label %19, label %49
19: ; preds = %15
%20 = getelementptr inbounds [150 x i8], [150 x i8]* %9, i64 0, i64 0
%21 = call i32 @strlen(i8* %20)
store i32 %21, i32* %6
%22 = load i32, i32* %6
%23 = load i32, i32* %7
%24 = icmp sgt i32 %22, %23
br i1 %24, label %25, label %27
25: ; preds = %19
%26 = load i32, i32* %6
store i32 %26, i32* %7
br label %27
27: ; preds = %25, %19
store i32 0, i32* %3
br label %28
28: ; preds = %43, %27
%29 = load i32, i32* %3
%30 = load i32, i32* %6
%31 = icmp sle i32 %29, %30
br i1 %31, label %32, label %46
32: ; preds = %28
%33 = load i32, i32* %3
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [150 x i8], [150 x i8]* %9, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = load i32, i32* %3
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %10, i64 0, i64 %38
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [150 x i8], [150 x i8]* %39, i64 0, i64 %41
store i8 %36, i8* %42
br label %43
43: ; preds = %32
%44 = load i32, i32* %3
%45 = add nsw i32 %44, 1
store i32 %45, i32* %3
br label %28
46: ; preds = %28
%47 = load i32, i32* %2
%48 = add nsw i32 %47, 1
store i32 %48, i32* %2
br label %15
49: ; preds = %15
%50 = load i32, i32* %2
%51 = sub nsw i32 %50, 1
store i32 %51, i32* %8
store i32 0, i32* %4
br label %52
52: ; preds = %81, %49
%53 = load i32, i32* %4
%54 = load i32, i32* %7
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %84
56: ; preds = %52
%57 = load i32, i32* %8
store i32 %57, i32* %3
br label %58
58: ; preds = %77, %56
%59 = load i32, i32* %3
%60 = icmp sge i32 %59, 0
br i1 %60, label %61, label %80
61: ; preds = %58
%62 = load i32, i32* %4
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %10, i64 0, i64 %63
%65 = load i32, i32* %3
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [150 x i8], [150 x i8]* %64, i64 0, i64 %66
%68 = load i8, i8* %67
%69 = load i32, i32* %4
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %11, i64 0, i64 %70
%72 = load i32, i32* %8
%73 = load i32, i32* %3
%74 = sub nsw i32 %72, %73
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [150 x i8], [150 x i8]* %71, i64 0, i64 %75
store i8 %68, i8* %76
br label %77
77: ; preds = %61
%78 = load i32, i32* %3
%79 = add nsw i32 %78, -1
store i32 %79, i32* %3
br label %58
80: ; preds = %58
br label %81
81: ; preds = %80
%82 = load i32, i32* %4
%83 = add nsw i32 %82, 1
store i32 %83, i32* %4
br label %52
84: ; preds = %52
%85 = load i32, i32* %4
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %10, i64 0, i64 %86
%88 = load i32, i32* %3
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [150 x i8], [150 x i8]* %87, i64 0, i64 %89
store i8 0, i8* %90
store i32 0, i32* %4
br label %91
91: ; preds = %121, %84
%92 = load i32, i32* %4
%93 = load i32, i32* %7
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %124
95: ; preds = %91
store i32 0, i32* %3
br label %96
96: ; preds = %116, %95
%97 = load i32, i32* %4
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %11, i64 0, i64 %98
%100 = load i32, i32* %3
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [150 x i8], [150 x i8]* %99, i64 0, i64 %101
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = icmp ne i32 %104, 0
br i1 %105, label %106, label %119
106: ; preds = %96
%107 = load i32, i32* %4
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [150 x [150 x i8]], [150 x [150 x i8]]* %11, i64 0, i64 %108
%110 = load i32, i32* %3
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [150 x i8], [150 x i8]* %109, i64 0, i64 %111
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %114)
br label %116
116: ; preds = %106
%117 = load i32, i32* %3
%118 = add nsw i32 %117, 1
store i32 %118, i32* %3
br label %96
119: ; preds = %96
%120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %121
121: ; preds = %119
%122 = load i32, i32* %4
%123 = add nsw i32 %122, 1
store i32 %123, i32* %4
br label %91
124: ; preds = %91
ret i32 0
}

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