#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*/ printf(char *, char *);
int /*<<< orphan*/ scanf(char *, char *);
int string_length(char *);
int main() {
  char a[105];
  scanf("%s", a);
  int i, x = string_length(a);
  if (x % 2 == 0) {
    for (i = 0; i < x / 2; i++) {
      char c = a[i];
      a[i] = a[(x / 2) + i];
      a[(x / 2) + i] = c;
    }
  } else {
    for (i = 0; i < ((x - 1) / 2); i++) {
      char d = a[i];
      a[i] = a[((x - 1) / 2) + (i + 1)];
      a[((x - 1) / 2) + (i + 1)] = d;
    }
  }
  printf("%s", a);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x70(%rbp),%rsi
lea    0xeb3(%rip),%rdi
call   1050 <scanf@plt>
lea    -0x70(%rbp),%rdi
call   1040 <string_length@plt>
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11e8 <main+0xb8>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x78(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
cmp    %ecx,%eax
jge    11e3 <main+0xb3>
movslq -0x74(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%al
mov    %al,-0x79(%rbp)
mov    -0x78(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x74(%rbp),%eax
cltq
mov    -0x70(%rbp,%rax,1),%cl
movslq -0x74(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x79(%rbp),%cl
mov    -0x78(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
add    -0x74(%rbp),%eax
cltq
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1179 <main+0x49>
jmp    1277 <main+0x147>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x78(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
cmp    %ecx,%eax
jge    1272 <main+0x142>
movslq -0x74(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%al
mov    %al,-0x7a(%rbp)
mov    -0x78(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
add    %ecx,%eax
cltq
mov    -0x70(%rbp,%rax,1),%cl
movslq -0x74(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x7a(%rbp),%cl
mov    -0x78(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x74(%rbp),%edx
add    $0x1,%edx
add    %edx,%eax
cltq
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11ef <main+0xbf>
jmp    1277 <main+0x147>
lea    -0x70(%rbp),%rsi
lea    0xd7e(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x78,%rsp
lea    0xec2(%rip),%rdi
mov    %rsp,%r14
mov    %r14,%rsi
call   1050 <scanf@plt>
mov    %r14,%rdi
call   1040 <string_length@plt>
test   $0x1,%al
jne    11fe <main+0xce>
cmp    $0x2,%eax
jl     12bc <main+0x18c>
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
sar    %edx
movslq %edx,%r9
mov    %r9d,%r10d
cmp    $0x8,%r9d
jb     1198 <main+0x68>
lea    (%r9,%r10,1),%rsi
add    %rsp,%rsi
cmp    %rsi,%r14
jae    12d5 <main+0x1a5>
lea    (%rsp,%r10,1),%rsi
lea    (%rsp,%r9,1),%rdi
cmp    %rsi,%rdi
jae    12d5 <main+0x1a5>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r10b
je     11ba <main+0x8a>
mov    (%rsp,%rdx,1),%cl
lea    (%rdx,%r9,1),%rdi
mov    (%rsp,%rdi,1),%bl
mov    %bl,(%rsp,%rdx,1)
mov    %cl,(%rsp,%rdi,1)
or     $0x1,%rdx
add    %r10,%rsi
je     12bc <main+0x18c>
lea    (%r9,%r14,1),%rcx
add    $0x1,%rcx
nopl   0x0(%rax,%rax,1)
movzbl (%rsp,%rdx,1),%ebx
movzbl -0x1(%rcx,%rdx,1),%eax
mov    %al,(%rsp,%rdx,1)
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl 0x1(%rsp,%rdx,1),%eax
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rsp,%rdx,1)
mov    %al,(%rcx,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    11d0 <main+0xa0>
jmp    12bc <main+0x18c>
cmp    $0x3,%eax
jl     12bc <main+0x18c>
mov    %eax,%ecx
add    $0xffffffff,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
add    $0xffffffff,%eax
sar    %eax
movslq %eax,%r9
cmp    $0x2,%r9d
mov    $0x1,%esi
cmovge %r9d,%esi
cmp    $0x8,%esi
jb     1254 <main+0x124>
lea    (%r9,%r14,1),%rax
add    $0x1,%rax
lea    (%r9,%rsi,1),%rcx
add    %rsp,%rcx
add    $0x1,%rcx
cmp    %rcx,%r14
jae    12e1 <main+0x1b1>
lea    (%rsp,%rsi,1),%rcx
cmp    %rcx,%rax
jae    12e1 <main+0x1b1>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
test   $0x1,%sil
je     127e <main+0x14e>
mov    (%rsp,%rdx,1),%r8b
mov    %rdx,%rax
or     $0x1,%rax
lea    (%rax,%r9,1),%rdi
mov    (%rsp,%rdi,1),%bl
mov    %bl,(%rsp,%rdx,1)
mov    %r8b,(%rsp,%rdi,1)
mov    %rax,%rdx
add    %rsi,%rcx
je     12bc <main+0x18c>
lea    (%r9,%r14,1),%rcx
add    $0x2,%rcx
nopl   0x0(%rax,%rax,1)
movzbl (%rsp,%rdx,1),%ebx
movzbl -0x1(%rcx,%rdx,1),%eax
mov    %al,(%rsp,%rdx,1)
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl 0x1(%rsp,%rdx,1),%eax
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rsp,%rdx,1)
mov    %al,(%rcx,%rdx,1)
lea    0x2(%rdx),%rax
mov    %rax,%rdx
cmp    %rax,%rsi
jne    1290 <main+0x160>
lea    0xd3d(%rip),%rdi
mov    %rsp,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%edx
jae    12f1 <main+0x1c1>
xor    %edx,%edx
jmp    144e <main+0x31e>
cmp    $0x20,%esi
jae    137b <main+0x24b>
xor    %edx,%edx
jmp    14cf <main+0x39f>
mov    %r10d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     140b <main+0x2db>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rsp,%r9,1),%rbx
add    $0x30,%rbx
xor    %edi,%edi
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
movups -0x30(%rbx,%rdi,1),%xmm2
movups -0x20(%rbx,%rdi,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,-0x30(%rbx,%rdi,1)
movups %xmm1,-0x20(%rbx,%rdi,1)
movaps 0x20(%rsp,%rdi,1),%xmm0
movaps 0x30(%rsp,%rdi,1),%xmm1
movups -0x10(%rbx,%rdi,1),%xmm2
movups (%rbx,%rdi,1),%xmm3
movaps %xmm2,0x20(%rsp,%rdi,1)
movaps %xmm3,0x30(%rsp,%rdi,1)
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1320 <main+0x1f0>
jmp    140d <main+0x2dd>
mov    %esi,%edx
and    $0x7fffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1486 <main+0x356>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r9,%r14,1),%rcx
add    $0x31,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
movups -0x30(%rcx,%rdi,1),%xmm2
movups -0x20(%rcx,%rdi,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,-0x30(%rcx,%rdi,1)
movups %xmm1,-0x20(%rcx,%rdi,1)
movaps 0x20(%rsp,%rdi,1),%xmm0
movaps 0x30(%rsp,%rdi,1),%xmm1
movups -0x10(%rcx,%rdi,1),%xmm2
movups (%rcx,%rdi,1),%xmm3
movaps %xmm2,0x20(%rsp,%rdi,1)
movaps %xmm3,0x30(%rsp,%rdi,1)
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbx
jne    13b0 <main+0x280>
jmp    1488 <main+0x358>
xor    %edi,%edi
test   $0x1,%r8b
je     143b <main+0x30b>
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
lea    (%rdi,%r9,1),%rsi
movups (%rsp,%rsi,1),%xmm2
movups 0x10(%rsp,%rsi,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,(%rsp,%rsi,1)
movups %xmm1,0x10(%rsp,%rsi,1)
cmp    %r10,%rdx
je     12bc <main+0x18c>
test   $0x18,%r10b
je     119a <main+0x6a>
mov    %rdx,%rsi
mov    %r10d,%edx
and    $0xfffffff8,%edx
lea    (%rsp,%rsi,1),%rdi
sub    %rdx,%rsi
xchg   %ax,%ax
mov    (%rdi),%rbx
mov    (%rdi,%r9,1),%rcx
mov    %rcx,(%rdi)
mov    %rbx,(%rdi,%r9,1)
add    $0x8,%rdi
add    $0x8,%rsi
jne    1460 <main+0x330>
cmp    %r10,%rdx
je     12bc <main+0x18c>
jmp    119a <main+0x6a>
xor    %edi,%edi
test   $0x1,%r8b
je     14bc <main+0x38c>
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
mov    %rdi,%rcx
or     $0x1,%rcx
add    %r9,%rcx
movups (%rsp,%rcx,1),%xmm2
movups 0x10(%rsp,%rcx,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %rsi,%rdx
je     12bc <main+0x18c>
test   $0x18,%sil
je     1256 <main+0x126>
mov    %rdx,%rcx
mov    %esi,%edx
and    $0x7ffffff8,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rsp,%rcx,1),%rdi
mov    (%rax,%rcx,1),%rbx
mov    %rbx,(%rsp,%rcx,1)
mov    %rdi,(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    14e0 <main+0x3b0>
cmp    %rsi,%rdx
je     12bc <main+0x18c>
jmp    1256 <main+0x126>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca [105 x i8]
%2 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 0
%3 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 0
%4 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %3)
%5 = call i32 @string_length(i8* %3)
%6 = and i32 %5, 1
%7 = icmp eq i32 %6, 0
br i1 %7, label %143, label %8
8: ; preds = %0
%9 = add nsw i32 %5, -1
%10 = sdiv i32 %9, 2
%11 = icmp sgt i32 %5, 2
br i1 %11, label %12, label %300
12: ; preds = %8
%13 = sext i32 %10 to i64
%14 = call i32 @llvm.smax.i32(i32 %10, i32 1)
%15 = zext i32 %14 to i64
%16 = icmp ult i32 %14, 8
br i1 %16, label %127, label %17
17: ; preds = %12
%18 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %15
%19 = add nsw i64 %13, 1
%20 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %19
%21 = add nsw i64 %13, %15
%22 = add nsw i64 %21, 1
%23 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %22
%24 = icmp ult i8* %2, %23
%25 = icmp ult i8* %20, %18
%26 = and i1 %24, %25
br i1 %26, label %127, label %27
27: ; preds = %17
%28 = icmp ult i32 %14, 32
br i1 %28, label %108, label %29
29: ; preds = %27
%30 = and i64 %15, 2147483616
%31 = add nsw i64 %30, -32
%32 = lshr exact i64 %31, 5
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 1
%35 = icmp eq i64 %31, 0
br i1 %35, label %81, label %36
36: ; preds = %29
%37 = and i64 %33, 1152921504606846974
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %78, %38 ]
%40 = phi i64 [ 0, %36 ], [ %79, %38 ]
%41 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %39
%42 = bitcast i8* %41 to <16 x i8>*
%43 = load <16 x i8>, <16 x i8>* %42
%44 = getelementptr inbounds i8, i8* %41, i64 16
%45 = bitcast i8* %44 to <16 x i8>*
%46 = load <16 x i8>, <16 x i8>* %45
%47 = or i64 %39, 1
%48 = add nsw i64 %47, %13
%49 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %48
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = getelementptr inbounds i8, i8* %49, i64 16
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = bitcast i8* %41 to <16 x i8>*
store <16 x i8> %51, <16 x i8>* %55
%56 = bitcast i8* %44 to <16 x i8>*
store <16 x i8> %54, <16 x i8>* %56
%57 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %57
%58 = bitcast i8* %52 to <16 x i8>*
store <16 x i8> %46, <16 x i8>* %58
%59 = or i64 %39, 32
%60 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %59
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = getelementptr inbounds i8, i8* %60, i64 16
%64 = bitcast i8* %63 to <16 x i8>*
%65 = load <16 x i8>, <16 x i8>* %64
%66 = or i64 %39, 33
%67 = add nsw i64 %66, %13
%68 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %67
%69 = bitcast i8* %68 to <16 x i8>*
%70 = load <16 x i8>, <16 x i8>* %69
%71 = getelementptr inbounds i8, i8* %68, i64 16
%72 = bitcast i8* %71 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %70, <16 x i8>* %74
%75 = bitcast i8* %63 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %75
%76 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %76
%77 = bitcast i8* %71 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %77
%78 = add nuw i64 %39, 64
%79 = add i64 %40, 2
%80 = icmp eq i64 %79, %37
br i1 %80, label %81, label %38
81: ; preds = %38, %29
%82 = phi i64 [ 0, %29 ], [ %78, %38 ]
%83 = icmp eq i64 %34, 0
br i1 %83, label %103, label %84
84: ; preds = %81
%85 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %82
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %85, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = or i64 %82, 1
%92 = add nsw i64 %91, %13
%93 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %92
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = bitcast i8* %85 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %99
%100 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %100
%101 = bitcast i8* %93 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %101
%102 = bitcast i8* %96 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %102
br label %103
103: ; preds = %81, %84
%104 = icmp eq i64 %30, %15
br i1 %104, label %300, label %105
105: ; preds = %103
%106 = and i64 %15, 24
%107 = icmp eq i64 %106, 0
br i1 %107, label %127, label %108
108: ; preds = %27, %105
%109 = phi i64 [ %30, %105 ], [ 0, %27 ]
%110 = and i64 %15, 2147483640
br label %111
111: ; preds = %111, %108
%112 = phi i64 [ %109, %108 ], [ %123, %111 ]
%113 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %112
%114 = bitcast i8* %113 to <8 x i8>*
%115 = load <8 x i8>, <8 x i8>* %114
%116 = or i64 %112, 1
%117 = add nsw i64 %116, %13
%118 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %117
%119 = bitcast i8* %118 to <8 x i8>*
%120 = load <8 x i8>, <8 x i8>* %119
%121 = bitcast i8* %113 to <8 x i8>*
store <8 x i8> %120, <8 x i8>* %121
%122 = bitcast i8* %118 to <8 x i8>*
store <8 x i8> %115, <8 x i8>* %122
%123 = add nuw i64 %112, 8
%124 = icmp eq i64 %123, %110
br i1 %124, label %125, label %111
125: ; preds = %111
%126 = icmp eq i64 %110, %15
br i1 %126, label %300, label %127
127: ; preds = %17, %12, %105, %125
%128 = phi i64 [ 0, %12 ], [ 0, %17 ], [ %30, %105 ], [ %110, %125 ]
%129 = xor i64 %128, -1
%130 = and i64 %15, 1
%131 = icmp eq i64 %130, 0
br i1 %131, label %139, label %132
132: ; preds = %127
%133 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %128
%134 = load i8, i8* %133
%135 = or i64 %128, 1
%136 = add nsw i64 %135, %13
%137 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %136
%138 = load i8, i8* %137
store i8 %138, i8* %133
store i8 %134, i8* %137
br label %139
139: ; preds = %132, %127
%140 = phi i64 [ %128, %127 ], [ %135, %132 ]
%141 = sub nsw i64 0, %15
%142 = icmp eq i64 %129, %141
br i1 %142, label %300, label %285
143: ; preds = %0
%144 = sdiv i32 %5, 2
%145 = icmp sgt i32 %5, 1
br i1 %145, label %146, label %300
146: ; preds = %143
%147 = sext i32 %144 to i64
%148 = zext i32 %144 to i64
%149 = icmp ult i32 %144, 8
br i1 %149, label %254, label %150
150: ; preds = %146
%151 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %148
%152 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %147
%153 = add nsw i64 %147, %148
%154 = getelementptr [105 x i8], [105 x i8]* %1, i64 0, i64 %153
%155 = icmp ult i8* %2, %154
%156 = icmp ult i8* %152, %151
%157 = and i1 %155, %156
br i1 %157, label %254, label %158
158: ; preds = %150
%159 = icmp ult i32 %144, 32
br i1 %159, label %236, label %160
160: ; preds = %158
%161 = and i64 %148, 4294967264
%162 = add nsw i64 %161, -32
%163 = lshr exact i64 %162, 5
%164 = add nuw nsw i64 %163, 1
%165 = and i64 %164, 1
%166 = icmp eq i64 %162, 0
br i1 %166, label %210, label %167
167: ; preds = %160
%168 = and i64 %164, 1152921504606846974
br label %169
169: ; preds = %169, %167
%170 = phi i64 [ 0, %167 ], [ %207, %169 ]
%171 = phi i64 [ 0, %167 ], [ %208, %169 ]
%172 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %170
%173 = bitcast i8* %172 to <16 x i8>*
%174 = load <16 x i8>, <16 x i8>* %173
%175 = getelementptr inbounds i8, i8* %172, i64 16
%176 = bitcast i8* %175 to <16 x i8>*
%177 = load <16 x i8>, <16 x i8>* %176
%178 = add nsw i64 %170, %147
%179 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %178
%180 = bitcast i8* %179 to <16 x i8>*
%181 = load <16 x i8>, <16 x i8>* %180
%182 = getelementptr inbounds i8, i8* %179, i64 16
%183 = bitcast i8* %182 to <16 x i8>*
%184 = load <16 x i8>, <16 x i8>* %183
%185 = bitcast i8* %172 to <16 x i8>*
store <16 x i8> %181, <16 x i8>* %185
%186 = bitcast i8* %175 to <16 x i8>*
store <16 x i8> %184, <16 x i8>* %186
%187 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %174, <16 x i8>* %187
%188 = bitcast i8* %182 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %188
%189 = or i64 %170, 32
%190 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %189
%191 = bitcast i8* %190 to <16 x i8>*
%192 = load <16 x i8>, <16 x i8>* %191
%193 = getelementptr inbounds i8, i8* %190, i64 16
%194 = bitcast i8* %193 to <16 x i8>*
%195 = load <16 x i8>, <16 x i8>* %194
%196 = add nsw i64 %189, %147
%197 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %196
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr inbounds i8, i8* %197, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = bitcast i8* %190 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %203
%204 = bitcast i8* %193 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %204
%205 = bitcast i8* %197 to <16 x i8>*
store <16 x i8> %192, <16 x i8>* %205
%206 = bitcast i8* %200 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %206
%207 = add nuw i64 %170, 64
%208 = add i64 %171, 2
%209 = icmp eq i64 %208, %168
br i1 %209, label %210, label %169
210: ; preds = %169, %160
%211 = phi i64 [ 0, %160 ], [ %207, %169 ]
%212 = icmp eq i64 %165, 0
br i1 %212, label %231, label %213
213: ; preds = %210
%214 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %211
%215 = bitcast i8* %214 to <16 x i8>*
%216 = load <16 x i8>, <16 x i8>* %215
%217 = getelementptr inbounds i8, i8* %214, i64 16
%218 = bitcast i8* %217 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = add nsw i64 %211, %147
%221 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %220
%222 = bitcast i8* %221 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = getelementptr inbounds i8, i8* %221, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = bitcast i8* %214 to <16 x i8>*
store <16 x i8> %223, <16 x i8>* %227
%228 = bitcast i8* %217 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %228
%229 = bitcast i8* %221 to <16 x i8>*
store <16 x i8> %216, <16 x i8>* %229
%230 = bitcast i8* %224 to <16 x i8>*
store <16 x i8> %219, <16 x i8>* %230
br label %231
231: ; preds = %210, %213
%232 = icmp eq i64 %161, %148
br i1 %232, label %300, label %233
233: ; preds = %231
%234 = and i64 %148, 24
%235 = icmp eq i64 %234, 0
br i1 %235, label %254, label %236
236: ; preds = %158, %233
%237 = phi i64 [ %161, %233 ], [ 0, %158 ]
%238 = and i64 %148, 4294967288
br label %239
239: ; preds = %239, %236
%240 = phi i64 [ %237, %236 ], [ %250, %239 ]
%241 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %240
%242 = bitcast i8* %241 to <8 x i8>*
%243 = load <8 x i8>, <8 x i8>* %242
%244 = add nsw i64 %240, %147
%245 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %244
%246 = bitcast i8* %245 to <8 x i8>*
%247 = load <8 x i8>, <8 x i8>* %246
%248 = bitcast i8* %241 to <8 x i8>*
store <8 x i8> %247, <8 x i8>* %248
%249 = bitcast i8* %245 to <8 x i8>*
store <8 x i8> %243, <8 x i8>* %249
%250 = add nuw i64 %240, 8
%251 = icmp eq i64 %250, %238
br i1 %251, label %252, label %239
252: ; preds = %239
%253 = icmp eq i64 %238, %148
br i1 %253, label %300, label %254
254: ; preds = %150, %146, %233, %252
%255 = phi i64 [ 0, %146 ], [ 0, %150 ], [ %161, %233 ], [ %238, %252 ]
%256 = xor i64 %255, -1
%257 = and i64 %148, 1
%258 = icmp eq i64 %257, 0
br i1 %258, label %266, label %259
259: ; preds = %254
%260 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %255
%261 = load i8, i8* %260
%262 = add nsw i64 %255, %147
%263 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %262
%264 = load i8, i8* %263
store i8 %264, i8* %260
store i8 %261, i8* %263
%265 = or i64 %255, 1
br label %266
266: ; preds = %259, %254
%267 = phi i64 [ %255, %254 ], [ %265, %259 ]
%268 = sub nsw i64 0, %148
%269 = icmp eq i64 %256, %268
br i1 %269, label %300, label %270
270: ; preds = %266, %270
%271 = phi i64 [ %283, %270 ], [ %267, %266 ]
%272 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %271
%273 = load i8, i8* %272
%274 = add nsw i64 %271, %147
%275 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %274
%276 = load i8, i8* %275
store i8 %276, i8* %272
store i8 %273, i8* %275
%277 = add nuw nsw i64 %271, 1
%278 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %277
%279 = load i8, i8* %278
%280 = add nsw i64 %277, %147
%281 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %280
%282 = load i8, i8* %281
store i8 %282, i8* %278
store i8 %279, i8* %281
%283 = add nuw nsw i64 %271, 2
%284 = icmp eq i64 %283, %148
br i1 %284, label %300, label %270
285: ; preds = %139, %285
%286 = phi i64 [ %295, %285 ], [ %140, %139 ]
%287 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %286
%288 = load i8, i8* %287
%289 = add nuw nsw i64 %286, 1
%290 = add nsw i64 %289, %13
%291 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %290
%292 = load i8, i8* %291
store i8 %292, i8* %287
store i8 %288, i8* %291
%293 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %289
%294 = load i8, i8* %293
%295 = add nuw nsw i64 %286, 2
%296 = add nsw i64 %295, %13
%297 = getelementptr inbounds [105 x i8], [105 x i8]* %1, i64 0, i64 %296
%298 = load i8, i8* %297
store i8 %298, i8* %293
store i8 %294, i8* %297
%299 = icmp eq i64 %295, %15
br i1 %299, label %300, label %285
300: ; preds = %139, %285, %266, %270, %103, %125, %231, %252, %8, %143
%301 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %3)
ret i32 0
}