#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;
    }
  }
  for (i = 0; i < ((x - 1) / 2); i++) {
    char d = a[i];
    a[i] = a[(x - 1) / 2 + i];
    a[(x - 1) / 2 + i] = 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    11e8 <main+0xb8>
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    1268 <main+0x138>
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
add    -0x74(%rbp),%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
add    -0x74(%rbp),%eax
cltq
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11ef <main+0xbf>
lea    -0x70(%rbp),%rsi
lea    0xd8d(%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    11f9 <main+0xc9>
cmp    $0x2,%eax
jl     12a9 <main+0x179>
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    12cf <main+0x19f>
lea    (%rsp,%r10,1),%rsi
lea    (%rsp,%r9,1),%rdi
cmp    %rsi,%rdi
jae    12cf <main+0x19f>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
test   $0x1,%r10b
je     11ba <main+0x8a>
mov    (%rsp,%rsi,1),%cl
lea    (%rsi,%r9,1),%rdi
mov    (%rsp,%rdi,1),%bl
mov    %bl,(%rsp,%rsi,1)
mov    %cl,(%rsp,%rdi,1)
or     $0x1,%rsi
add    %r10,%rdx
je     11f9 <main+0xc9>
lea    (%r9,%r14,1),%rdx
add    $0x1,%rdx
nopw   0x0(%rax,%rax,1)
movzbl (%rsp,%rsi,1),%ecx
movzbl -0x1(%rdx,%rsi,1),%ebx
mov    %bl,(%rsp,%rsi,1)
mov    %cl,-0x1(%rdx,%rsi,1)
movzbl 0x1(%rsp,%rsi,1),%ecx
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,0x1(%rsp,%rsi,1)
mov    %cl,(%rdx,%rsi,1)
add    $0x2,%rsi
cmp    %rsi,%r10
jne    11d0 <main+0xa0>
cmp    $0x3,%eax
jl     12a9 <main+0x179>
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,%r10d
cmovge %r9d,%r10d
cmp    $0x8,%r10d
jb     1245 <main+0x115>
lea    (%r9,%r10,1),%rdx
add    %rsp,%rdx
cmp    %rdx,%r14
jae    12c2 <main+0x192>
lea    (%rsp,%r10,1),%rdx
lea    (%rsp,%r9,1),%rsi
cmp    %rdx,%rsi
jae    12c2 <main+0x192>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r10b
je     1267 <main+0x137>
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     12a9 <main+0x179>
lea    (%r9,%r14,1),%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1280 <main+0x150>
lea    0xd50(%rip),%rdi
mov    %rsp,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r10d
jae    12df <main+0x1af>
xor    %edx,%edx
jmp    144e <main+0x31e>
cmp    $0x20,%edx
jae    137b <main+0x24b>
xor    %esi,%esi
jmp    14d9 <main+0x3a9>
mov    %r10d,%edx
and    $0x7fffffe0,%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
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    %r10d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdx
mov    %rdx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1496 <main+0x366>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsp,%r9,1),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
movups -0x30(%rdx,%rdi,1),%xmm2
movups -0x20(%rdx,%rdi,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,-0x30(%rdx,%rdi,1)
movups %xmm1,-0x20(%rdx,%rdi,1)
movaps 0x20(%rsp,%rdi,1),%xmm0
movaps 0x30(%rsp,%rdi,1),%xmm1
movups -0x10(%rdx,%rdi,1),%xmm2
movups (%rdx,%rdi,1),%xmm3
movaps %xmm2,0x20(%rsp,%rdi,1)
movaps %xmm3,0x30(%rsp,%rdi,1)
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbx
jne    13b0 <main+0x280>
jmp    1498 <main+0x368>
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     12a9 <main+0x179>
test   $0x18,%r10b
je     1247 <main+0x117>
mov    %rdx,%rsi
mov    %r10d,%edx
and    $0x7ffffff8,%edx
lea    (%rsp,%rsi,1),%rdi
sub    %rdx,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi),%rbx
mov    (%rdi,%r9,1),%rcx
mov    %rcx,(%rdi)
mov    %rbx,(%rdi,%r9,1)
add    $0x8,%rdi
add    $0x8,%rsi
jne    1470 <main+0x340>
cmp    %r10,%rdx
je     12a9 <main+0x179>
jmp    1247 <main+0x117>
xor    %edi,%edi
test   $0x1,%r8b
je     14c6 <main+0x396>
movaps (%rsp,%rdi,1),%xmm0
movaps 0x10(%rsp,%rdi,1),%xmm1
lea    (%rdi,%r9,1),%rdx
movups (%rsp,%rdx,1),%xmm2
movups 0x10(%rsp,%rdx,1),%xmm3
movaps %xmm2,(%rsp,%rdi,1)
movaps %xmm3,0x10(%rsp,%rdi,1)
movups %xmm0,(%rsp,%rdx,1)
movups %xmm1,0x10(%rsp,%rdx,1)
cmp    %r10,%rsi
je     11f9 <main+0xc9>
test   $0x18,%r10b
je     119a <main+0x6a>
mov    %rsi,%rdx
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    (%rsp,%rdx,1),%rdi
sub    %rsi,%rdx
nopl   0x0(%rax)
mov    (%rdi),%rbx
mov    (%rdi,%r9,1),%rcx
mov    %rcx,(%rdi)
mov    %rbx,(%rdi,%r9,1)
add    $0x8,%rdi
add    $0x8,%rdx
jne    14f0 <main+0x3c0>
cmp    %r10,%rsi
je     11f9 <main+0xc9>
jmp    119a <main+0x6a>

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