#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 */
scalar_t__ EOF;
int /*<<< orphan*/ puts(char *);
scalar_t__ scanf(char *, char *);
int strlen(char *);
int main(void) {
  char buf1[7], buf2[7], *curr, *next, *tmp;
  int curr_len, next_len, i;
  curr = buf1;
  next = buf2;
  scanf("%*d\n%s", curr);
  curr_len = strlen(curr);
  while (scanf("%s", next) != EOF) {
    next_len = strlen(next);
    if (next_len > curr_len) {
      tmp = curr;
      curr = next;
      next = tmp;
      curr_len = next_len;
    } else if (next_len == curr_len) {
      for (i = curr_len - 1; i >= 0; i--) {
        if (next[i] < curr[i])
          break;
        if (next[i] > curr[i]) {
          tmp = curr;
          curr = next;
          next = tmp;
          curr_len = next_len;
          break;
        }
      }
    }
  }
  for (i = 0; i < curr_len; i++)
    next[i] = curr[curr_len - i - 1];
  next[curr_len] = 0;
  puts(next);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xb(%rbp),%rax
mov    %rax,-0x20(%rbp)
lea    -0x12(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rsi
lea    0xea6(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rsi
lea    0xe8e(%rip),%rdi
call   1050 <scanf@plt>
mov    0x2e66(%rip),%rcx
cmp    (%rcx),%rax
je     126f <main+0x13f>
mov    -0x28(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    11c6 <main+0x96>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    126a <main+0x13a>
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    1265 <main+0x135>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1260 <main+0x130>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jge    120a <main+0xda>
jmp    1260 <main+0x130>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jle    124d <main+0x11d>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1260 <main+0x130>
jmp    1252 <main+0x122>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    11db <main+0xab>
jmp    1265 <main+0x135>
jmp    126a <main+0x13a>
jmp    116b <main+0x3b>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12ae <main+0x17e>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1276 <main+0x146>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
lea    0x11(%rsp),%r13
lea    0xa(%rsp),%r12
lea    0xeb1(%rip),%rdi
mov    %r13,%rsi
call   1050 <scanf@plt>
mov    %r13,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
lea    0xe9c(%rip),%rdi
mov    %r12,%rsi
call   1050 <scanf@plt>
mov    0x2e71(%rip),%rcx
cmp    (%rcx),%rax
jne    119c <main+0x6c>
mov    %ebp,%r15d
test   %r15d,%r15d
jle    13c8 <main+0x298>
mov    %r15d,%eax
cmp    $0x8,%r15d
jae    122b <main+0xfb>
xor    %ecx,%ecx
jmp    1358 <main+0x228>
lea    0xa(%rsp),%rbx
lea    0x11(%rsp),%r14
jmp    11dd <main+0xad>
nopl   0x0(%rax,%rax,1)
mov    %eax,%r15d
mov    %r14,%r12
lea    0xe47(%rip),%rdi
mov    %r12,%rsi
call   1050 <scanf@plt>
mov    %rbx,%r13
mov    %rbx,%r14
mov    %r15d,%ebp
mov    %r12,%rbx
mov    0x2e10(%rip),%rcx
cmp    (%rcx),%rax
je     117f <main+0x4f>
mov    %rbx,%rdi
call   1040 <strlen@plt>
cmp    %ebp,%eax
jg     11b0 <main+0x80>
jne    1220 <main+0xf0>
mov    %ebp,%eax
nopl   (%rax)
test   %eax,%eax
jle    1220 <main+0xf0>
movzbl -0x1(%rbx,%rax,1),%ecx
movzbl -0x1(%r14,%rax,1),%edx
cmp    %dl,%cl
jl     1220 <main+0xf0>
add    $0xffffffffffffffff,%rax
cmp    %dl,%cl
jle    11f0 <main+0xc0>
mov    %r14,%r12
mov    %ebp,%r15d
jmp    11b6 <main+0x86>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%r12
mov    %ebp,%r15d
mov    %r14,%rbx
jmp    11b6 <main+0x86>
lea    -0x1(%rax),%rsi
lea    -0x1(%r15),%edx
mov    %edx,%edi
sub    %esi,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jg     1358 <main+0x228>
shr    $0x20,%rsi
jne    1358 <main+0x228>
cmp    $0x20,%r15d
jae    1258 <main+0x128>
xor    %ecx,%ecx
jmp    1307 <main+0x1d7>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %edx,%rdx
movdqu -0x1f(%r13,%rdx,1),%xmm1
movdqu -0xf(%r13,%rdx,1),%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,(%r12,%rsi,1)
movdqu %xmm1,0x10(%r12,%rsi,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    1270 <main+0x140>
cmp    %rax,%rcx
je     13c8 <main+0x298>
test   $0x18,%al
je     1358 <main+0x228>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %r15d,%esi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
movq   -0x7(%r13,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r12,%rdx,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    1320 <main+0x1f0>
cmp    %rax,%rcx
je     13c8 <main+0x298>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1379 <main+0x249>
mov    %ecx,%esi
not    %esi
add    %r15d,%esi
movslq %esi,%rsi
mov    0x0(%r13,%rsi,1),%bl
mov    %bl,(%r12,%rcx,1)
or     $0x1,%rcx
add    %rax,%rdx
je     13c8 <main+0x298>
sub    %rcx,%rax
mov    %ecx,%edx
not    %edx
add    %r15d,%edx
add    %r12,%rcx
add    $0x1,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
movzbl 0x0(%r13,%rdx,1),%ebx
mov    %bl,-0x1(%rcx,%rsi,1)
lea    -0x1(%rdx),%edi
movslq %edi,%rdi
movzbl 0x0(%r13,%rdi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rax
jne    13a0 <main+0x270>
movslq %r15d,%rax
movb   $0x0,(%r12,%rax,1)
mov    %r12,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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