#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*/ getchar();
int /*<<< orphan*/ gets(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int strlen(char *);
int main() {
  int a, i, j, loop, k = 0;
  char ah[101];
  scanf("%d", &loop);
  getchar();
  for (i = 0; i < loop; i++) {
    gets(ah);
    a = strlen(ah);
    char am[a - 1];
    for (j = a / 2 - 1; j >= 0; j--) {
      am[k] = ah[j];
      k++;
    }
    for (j = a - 1; j >= a / 2; j--) {
      am[k] = ah[j];
      k++;
    }
    for (j = 0; j < a; j++) {
      printf("%c", am[j]);
    }
    printf("\n");
    k = 0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x18(%rbp)
lea    0xe90(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1070 <scanf@plt>
mov    $0x0,%al
call   1050 <getchar@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12f1 <main+0x1a1>
lea    -0x80(%rbp),%rdi
mov    %rdi,-0xa0(%rbp)
call   1060 <gets@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %rsp,%rcx
mov    %rcx,-0x88(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     122c <main+0xdc>
mov    -0x98(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    -0x80(%rbp,%rcx,1),%dl
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    11f5 <main+0xa5>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
cmp    %ecx,%eax
jl     1286 <main+0x136>
mov    -0x98(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    -0x80(%rbp,%rcx,1),%dl
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1235 <main+0xe5>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12c4 <main+0x174>
mov    -0x98(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xd54(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    128d <main+0x13d>
lea    0xd3b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,%rsp
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1187 <main+0x37>
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0xe98(%rip),%rdi
lea    -0x2c(%rbp),%rsi
call   1070 <scanf@plt>
xor    %r14d,%r14d
xor    %eax,%eax
call   1050 <getchar@plt>
cmpl   $0x0,-0x2c(%rbp)
jle    15bd <main+0x46d>
mov    $0xfffffffe,%r15d
jmp    11ac <main+0x5c>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x38(%rbp),%rsp
add    $0x1,%r14d
cmp    -0x2c(%rbp),%r14d
jge    15bd <main+0x46d>
lea    -0xa0(%rbp),%rbx
mov    %rbx,%rdi
call   1060 <gets@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rsp,-0x38(%rbp)
lea    -0x1(%rax),%ecx
mov    %rsp,%r13
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%r13
mov    %r13,%rsp
mov    %eax,%r9d
shr    $0x1f,%r9d
add    %eax,%r9d
sar    %r9d
xor    %edx,%edx
cmp    $0x2,%eax
pxor   %xmm3,%xmm3
jl     12a2 <main+0x152>
mov    %r9d,%r8d
cmp    $0x8,%r9d
jae    12d0 <main+0x180>
xor    %esi,%esi
mov    %r8,%rdi
mov    %rsi,%rbx
not    %rbx
add    %r8,%rbx
mov    %r8,%rdx
and    $0x3,%rdx
je     123d <main+0xed>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdi
mov    %edi,%ecx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
mov    %cl,0x0(%r13,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1220 <main+0xd0>
mov    %r9d,%edx
cmp    $0x3,%rbx
jb     12a2 <main+0x152>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%r15,1),%rcx
lea    0x1(%rcx),%edx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
mov    %dl,0x0(%r13,%rsi,1)
mov    %ecx,%edx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
mov    %dl,0x1(%r13,%rsi,1)
add    $0xffffffff,%ecx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
mov    %cl,0x2(%r13,%rsi,1)
add    $0xfffffffffffffffc,%rdi
mov    %edi,%ecx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
mov    %cl,0x3(%r13,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1250 <main+0x100>
mov    %r9d,%edx
cmp    %r9d,%eax
jle    1457 <main+0x307>
movslq %eax,%rbx
movslq %r9d,%r10
mov    %edx,%r9d
mov    %rbx,%r8
sub    %r10,%r8
cmp    $0x8,%r8
jae    1310 <main+0x1c0>
mov    %r9,%rsi
mov    %rbx,%rdx
jmp    1433 <main+0x2e3>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r8),%rbx
lea    -0x1(%r9),%edx
cmp    %ebx,%edx
jb     1204 <main+0xb4>
mov    %rbx,%rdx
shr    $0x20,%rdx
mov    $0x0,%esi
mov    %r8,%rdi
jne    1209 <main+0xb9>
cmp    $0x20,%r9d
jae    1489 <main+0x339>
xor    %esi,%esi
jmp    1541 <main+0x3f1>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x20,%r8
jae    131d <main+0x1cd>
xor    %edi,%edi
jmp    13d0 <main+0x280>
mov    %r8,%rdi
and    $0xffffffffffffffe0,%rdi
lea    -0xb0(%rbp),%rcx
lea    (%rcx,%rbx,1),%rdx
lea    (%r9,%r13,1),%rsi
add    $0x10,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqu -0x10(%rdx),%xmm0
movdqu (%rdx),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm1,-0x10(%rsi,%rcx,1)
movdqu %xmm0,(%rsi,%rcx,1)
add    $0x20,%rcx
add    $0xffffffffffffffe0,%rdx
cmp    %rcx,%rdi
jne    1340 <main+0x1f0>
cmp    %rdi,%r8
je     1457 <main+0x307>
test   $0x18,%r8b
je     15a7 <main+0x457>
mov    %r8,%r11
and    $0xfffffffffffffff8,%r11
lea    (%r11,%r9,1),%rsi
mov    %rbx,%rdx
sub    %r11,%rdx
sub    %rdi,%rbx
lea    -0xa8(%rbp),%rcx
add    %rcx,%rbx
add    %r13,%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rbx),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,(%r9,%rdi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rbx
cmp    %rdi,%r11
jne    1400 <main+0x2b0>
cmp    %r11,%r8
je     1457 <main+0x307>
add    %r13,%rsi
cs nopw 0x0(%rax,%rax,1)
movzbl -0xa1(%rbp,%rdx,1),%ecx
ff
add    $0xffffffffffffffff,%rdx
mov    %cl,(%rsi)
add    $0x1,%rsi
cmp    %r10,%rdx
jg     1440 <main+0x2f0>
test   %eax,%eax
jle    1190 <main+0x40>
mov    %eax,%ebx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl 0x0(%r13,%r12,1),%edi
call   1030 <putchar@plt>
add    $0x1,%r12
cmp    %r12,%rbx
jne    1470 <main+0x320>
jmp    1190 <main+0x40>
mov    %r8d,%esi
and    $0xffffffe0,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edx
movdqu -0xbf(%rbp,%rdx,1),%xmm0
ff ff
movdqu -0xaf(%rbp,%rdx,1),%xmm1
ff ff
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm1,0x0(%r13,%rdi,1)
movdqa %xmm0,0x10(%r13,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rbx
cmp    %rdi,%rsi
jne    14a0 <main+0x350>
mov    %r9d,%edx
cmp    %r8,%rsi
je     12a2 <main+0x152>
test   $0x18,%r8b
je     15b2 <main+0x462>
mov    %rsi,%rdx
mov    %r8d,%esi
and    $0xfffffff8,%esi
mov    %r8d,%edi
and    $0x7,%edi
mov    %rdx,%rbx
not    %rbx
add    %r8,%rbx
nopl   0x0(%rax)
mov    %ebx,%ecx
movq   -0xa7(%rbp,%rcx,1),%xmm0
ff ff
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0x0(%r13,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbx
cmp    %rdx,%rsi
jne    1560 <main+0x410>
mov    %r9d,%edx
cmp    %r8,%rsi
jne    1209 <main+0xb9>
jmp    12a2 <main+0x152>
sub    %rdi,%rbx
add    %rdi,%r9
jmp    12c0 <main+0x170>
mov    %r8d,%edi
and    $0x1f,%edi
jmp    1209 <main+0xb9>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%c\00"
@.str.2 = [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 [101 x i8]
%8 = alloca i8*
%9 = alloca i64
store i32 0, i32* %1
store i32 0, i32* %6
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %5)
%11 = call i32 (...) @getchar()
store i32 0, i32* %3
br label %12
12: ; preds = %84, %0
%13 = load i32, i32* %3
%14 = load i32, i32* %5
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %87
16: ; preds = %12
%17 = getelementptr inbounds [101 x i8], [101 x i8]* %7, i64 0, i64 0
%18 = call i32 @gets(i8* %17)
%19 = getelementptr inbounds [101 x i8], [101 x i8]* %7, i64 0, i64 0
%20 = call i32 @strlen(i8* %19)
store i32 %20, i32* %2
%21 = load i32, i32* %2
%22 = sub nsw i32 %21, 1
%23 = zext i32 %22 to i64
%24 = call i8* @llvm.stacksave()
store i8* %24, i8** %8
%25 = alloca i8, i64 %23
store i64 %23, i64* %9
%26 = load i32, i32* %2
%27 = sdiv i32 %26, 2
%28 = sub nsw i32 %27, 1
store i32 %28, i32* %4
br label %29
29: ; preds = %42, %16
%30 = load i32, i32* %4
%31 = icmp sge i32 %30, 0
br i1 %31, label %32, label %45
32: ; preds = %29
%33 = load i32, i32* %4
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [101 x i8], [101 x i8]* %7, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %25, i64 %38
store i8 %36, i8* %39
%40 = load i32, i32* %6
%41 = add nsw i32 %40, 1
store i32 %41, i32* %6
br label %42
42: ; preds = %32
%43 = load i32, i32* %4
%44 = add nsw i32 %43, -1
store i32 %44, i32* %4
br label %29
45: ; preds = %29
%46 = load i32, i32* %2
%47 = sub nsw i32 %46, 1
store i32 %47, i32* %4
br label %48
48: ; preds = %63, %45
%49 = load i32, i32* %4
%50 = load i32, i32* %2
%51 = sdiv i32 %50, 2
%52 = icmp sge i32 %49, %51
br i1 %52, label %53, label %66
53: ; preds = %48
%54 = load i32, i32* %4
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [101 x i8], [101 x i8]* %7, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = load i32, i32* %6
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %25, i64 %59
store i8 %57, i8* %60
%61 = load i32, i32* %6
%62 = add nsw i32 %61, 1
store i32 %62, i32* %6
br label %63
63: ; preds = %53
%64 = load i32, i32* %4
%65 = add nsw i32 %64, -1
store i32 %65, i32* %4
br label %48
66: ; preds = %48
store i32 0, i32* %4
br label %67
67: ; preds = %78, %66
%68 = load i32, i32* %4
%69 = load i32, i32* %2
%70 = icmp slt i32 %68, %69
br i1 %70, label %71, label %81
71: ; preds = %67
%72 = load i32, i32* %4
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %25, i64 %73
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %76)
br label %78
78: ; preds = %71
%79 = load i32, i32* %4
%80 = add nsw i32 %79, 1
store i32 %80, i32* %4
br label %67
81: ; preds = %67
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %6
%83 = load i8*, i8** %8
br label %84
84: ; preds = %81
%85 = load i32, i32* %3
%86 = add nsw i32 %85, 1
store i32 %86, i32* %3
br label %12
87: ; preds = %12
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [101 x i8]
%3 = bitcast i32* %1 to i8*
%4 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 0
%5 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%6 = call i32 (...) @getchar()
%7 = load i32, i32* %1
%8 = icmp sgt i32 %7, 0
br i1 %8, label %9, label %221
9: ; preds = %0, %216
%10 = phi i32 [ %218, %216 ], [ 0, %0 ]
%11 = call i32 @gets(i8* %4)
%12 = call i32 @strlen(i8* %4)
%13 = add nsw i32 %12, -1
%14 = zext i32 %13 to i64
%15 = call i8* @llvm.stacksave()
%16 = alloca i8, i64 %14
%17 = sdiv i32 %12, 2
%18 = icmp sgt i32 %12, 1
br i1 %18, label %19, label %102
19: ; preds = %9
%20 = zext i32 %17 to i64
%21 = icmp ult i32 %17, 8
br i1 %21, label %79, label %22
22: ; preds = %19
%23 = add nsw i64 %20, -1
%24 = add nsw i32 %17, -1
%25 = trunc i64 %23 to i32
%26 = icmp ult i32 %24, %25
%27 = icmp ugt i64 %23, 4294967295
%28 = or i1 %26, %27
br i1 %28, label %79, label %29
29: ; preds = %22
%30 = icmp ult i32 %17, 32
br i1 %30, label %59, label %31
31: ; preds = %29
%32 = and i64 %20, 4294967264
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %51, %33 ]
%35 = xor i64 %34, -1
%36 = add i64 %35, %20
%37 = and i64 %36, 4294967295
%38 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %37
%39 = getelementptr inbounds i8, i8* %38, i64 -15
%40 = bitcast i8* %39 to <16 x i8>*
%41 = load <16 x i8>, <16 x i8>* %40
%42 = shufflevector <16 x i8> %41, <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>
%43 = getelementptr inbounds i8, i8* %38, i64 -31
%44 = bitcast i8* %43 to <16 x i8>*
%45 = load <16 x i8>, <16 x i8>* %44
%46 = shufflevector <16 x i8> %45, <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>
%47 = getelementptr inbounds i8, i8* %16, i64 %34
%48 = bitcast i8* %47 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %48
%49 = getelementptr inbounds i8, i8* %47, i64 16
%50 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %46, <16 x i8>* %50
%51 = add nuw i64 %34, 32
%52 = icmp eq i64 %51, %32
br i1 %52, label %53, label %33
53: ; preds = %33
%54 = icmp eq i64 %32, %20
br i1 %54, label %102, label %55
55: ; preds = %53
%56 = and i64 %20, 31
%57 = and i64 %20, 24
%58 = icmp eq i64 %57, 0
br i1 %58, label %79, label %59
59: ; preds = %29, %55
%60 = phi i64 [ %32, %55 ], [ 0, %29 ]
%61 = and i64 %20, 4294967288
%62 = and i64 %20, 7
br label %63
63: ; preds = %63, %59
%64 = phi i64 [ %60, %59 ], [ %75, %63 ]
%65 = xor i64 %64, -1
%66 = add i64 %65, %20
%67 = and i64 %66, 4294967295
%68 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %67
%69 = getelementptr inbounds i8, i8* %68, i64 -7
%70 = bitcast i8* %69 to <8 x i8>*
%71 = load <8 x i8>, <8 x i8>* %70
%72 = shufflevector <8 x i8> %71, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%73 = getelementptr inbounds i8, i8* %16, i64 %64
%74 = bitcast i8* %73 to <8 x i8>*
store <8 x i8> %72, <8 x i8>* %74
%75 = add nuw i64 %64, 8
%76 = icmp eq i64 %75, %61
br i1 %76, label %77, label %63
77: ; preds = %63
%78 = icmp eq i64 %61, %20
br i1 %78, label %102, label %79
79: ; preds = %22, %19, %55, %77
%80 = phi i64 [ 0, %19 ], [ 0, %22 ], [ %32, %55 ], [ %61, %77 ]
%81 = phi i64 [ %20, %19 ], [ %20, %22 ], [ %56, %55 ], [ %62, %77 ]
%82 = xor i64 %80, -1
%83 = add nsw i64 %82, %20
%84 = and i64 %20, 3
%85 = icmp eq i64 %84, 0
br i1 %85, label %98, label %86
86: ; preds = %79, %86
%87 = phi i64 [ %95, %86 ], [ %80, %79 ]
%88 = phi i64 [ %90, %86 ], [ %81, %79 ]
%89 = phi i64 [ %96, %86 ], [ 0, %79 ]
%90 = add nsw i64 %88, -1
%91 = and i64 %90, 4294967295
%92 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %91
%93 = load i8, i8* %92
%94 = getelementptr inbounds i8, i8* %16, i64 %87
store i8 %93, i8* %94
%95 = add nuw nsw i64 %87, 1
%96 = add i64 %89, 1
%97 = icmp eq i64 %96, %84
br i1 %97, label %98, label %86
98: ; preds = %86, %79
%99 = phi i64 [ %80, %79 ], [ %95, %86 ]
%100 = phi i64 [ %81, %79 ], [ %90, %86 ]
%101 = icmp ult i64 %83, 3
br i1 %101, label %102, label %167
102: ; preds = %98, %167, %53, %77, %9
%103 = phi i32 [ 0, %9 ], [ %17, %77 ], [ %17, %53 ], [ %17, %167 ], [ %17, %98 ]
%104 = icmp sgt i32 %12, %17
br i1 %104, label %105, label %195
105: ; preds = %102
%106 = sext i32 %12 to i64
%107 = sext i32 %17 to i64
%108 = zext i32 %103 to i64
%109 = sub nsw i64 %106, %107
%110 = icmp ult i64 %109, 8
br i1 %110, label %164, label %111
111: ; preds = %105
%112 = icmp ult i64 %109, 32
br i1 %112, label %142, label %113
113: ; preds = %111
%114 = and i64 %109, -32
br label %115
115: ; preds = %115, %113
%116 = phi i64 [ 0, %113 ], [ %133, %115 ]
%117 = add i64 %116, %108
%118 = xor i64 %116, -1
%119 = add i64 %118, %106
%120 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %119
%121 = getelementptr inbounds i8, i8* %120, i64 -15
%122 = bitcast i8* %121 to <16 x i8>*
%123 = load <16 x i8>, <16 x i8>* %122
%124 = shufflevector <16 x i8> %123, <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>
%125 = getelementptr inbounds i8, i8* %120, i64 -31
%126 = bitcast i8* %125 to <16 x i8>*
%127 = load <16 x i8>, <16 x i8>* %126
%128 = shufflevector <16 x i8> %127, <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>
%129 = getelementptr inbounds i8, i8* %16, i64 %117
%130 = bitcast i8* %129 to <16 x i8>*
store <16 x i8> %124, <16 x i8>* %130
%131 = getelementptr inbounds i8, i8* %129, i64 16
%132 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> %128, <16 x i8>* %132
%133 = add nuw i64 %116, 32
%134 = icmp eq i64 %133, %114
br i1 %134, label %135, label %115
135: ; preds = %115
%136 = icmp eq i64 %109, %114
br i1 %136, label %195, label %137
137: ; preds = %135
%138 = sub nsw i64 %106, %114
%139 = add nsw i64 %114, %108
%140 = and i64 %109, 24
%141 = icmp eq i64 %140, 0
br i1 %141, label %164, label %142
142: ; preds = %111, %137
%143 = phi i64 [ %114, %137 ], [ 0, %111 ]
%144 = sub nsw i64 %106, %107
%145 = and i64 %144, -8
%146 = add nsw i64 %145, %108
%147 = sub nsw i64 %106, %145
br label %148
148: ; preds = %148, %142
%149 = phi i64 [ %143, %142 ], [ %160, %148 ]
%150 = add i64 %149, %108
%151 = xor i64 %149, -1
%152 = add i64 %151, %106
%153 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %152
%154 = getelementptr inbounds i8, i8* %153, i64 -7
%155 = bitcast i8* %154 to <8 x i8>*
%156 = load <8 x i8>, <8 x i8>* %155
%157 = shufflevector <8 x i8> %156, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%158 = getelementptr inbounds i8, i8* %16, i64 %150
%159 = bitcast i8* %158 to <8 x i8>*
store <8 x i8> %157, <8 x i8>* %159
%160 = add nuw i64 %149, 8
%161 = icmp eq i64 %160, %145
br i1 %161, label %162, label %148
162: ; preds = %148
%163 = icmp eq i64 %144, %145
br i1 %163, label %195, label %164
164: ; preds = %105, %137, %162
%165 = phi i64 [ %108, %105 ], [ %139, %137 ], [ %146, %162 ]
%166 = phi i64 [ %106, %105 ], [ %138, %137 ], [ %147, %162 ]
br label %199
167: ; preds = %98, %167
%168 = phi i64 [ %193, %167 ], [ %99, %98 ]
%169 = phi i64 [ %188, %167 ], [ %100, %98 ]
%170 = add i64 %169, 4294967295
%171 = and i64 %170, 4294967295
%172 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %171
%173 = load i8, i8* %172
%174 = getelementptr inbounds i8, i8* %16, i64 %168
store i8 %173, i8* %174
%175 = add nuw nsw i64 %168, 1
%176 = add i64 %169, 4294967294
%177 = and i64 %176, 4294967295
%178 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %177
%179 = load i8, i8* %178
%180 = getelementptr inbounds i8, i8* %16, i64 %175
store i8 %179, i8* %180
%181 = add nuw nsw i64 %168, 2
%182 = add i64 %169, 4294967293
%183 = and i64 %182, 4294967295
%184 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %183
%185 = load i8, i8* %184
%186 = getelementptr inbounds i8, i8* %16, i64 %181
store i8 %185, i8* %186
%187 = add nuw nsw i64 %168, 3
%188 = add nsw i64 %169, -4
%189 = and i64 %188, 4294967295
%190 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %189
%191 = load i8, i8* %190
%192 = getelementptr inbounds i8, i8* %16, i64 %187
store i8 %191, i8* %192
%193 = add nuw nsw i64 %168, 4
%194 = icmp eq i64 %193, %20
br i1 %194, label %102, label %167
195: ; preds = %199, %135, %162, %102
%196 = icmp sgt i32 %12, 0
br i1 %196, label %197, label %216
197: ; preds = %195
%198 = zext i32 %12 to i64
br label %208
199: ; preds = %164, %199
%200 = phi i64 [ %206, %199 ], [ %165, %164 ]
%201 = phi i64 [ %202, %199 ], [ %166, %164 ]
%202 = add nsw i64 %201, -1
%203 = getelementptr inbounds [101 x i8], [101 x i8]* %2, i64 0, i64 %202
%204 = load i8, i8* %203
%205 = getelementptr inbounds i8, i8* %16, i64 %200
store i8 %204, i8* %205
%206 = add nuw nsw i64 %200, 1
%207 = icmp sgt i64 %202, %107
br i1 %207, label %199, label %195
208: ; preds = %197, %208
%209 = phi i64 [ 0, %197 ], [ %214, %208 ]
%210 = getelementptr inbounds i8, i8* %16, i64 %209
%211 = load i8, i8* %210
%212 = sext i8 %211 to i32
%213 = call i32 @putchar(i32 %212)
%214 = add nuw nsw i64 %209, 1
%215 = icmp eq i64 %214, %198
br i1 %215, label %216, label %208
216: ; preds = %208, %195
%217 = call i32 @putchar(i32 10)
%218 = add nuw nsw i32 %10, 1
%219 = load i32, i32* %1
%220 = icmp slt i32 %218, %219
br i1 %220, label %9, label %221
221: ; preds = %216, %0
ret i32 0
}