#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 str_len(char *);
int main() {
  int temp, i, len;
  char str[100];
  scanf("%s", str);
  len = str_len(str);
  for (i = 0; i < len / 2; i++) {
    temp = str[i];
    str[i] = str[i + len / 2];
    str[i + len / 2] = temp;
  }
  for (i = 0; i < len / 2; i++) {
    temp = str[i];
    str[i] = str[i + len / 2 + 1];
    str[i + len / 2 + 1] = temp;
  }
  printf("%s", str);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x80(%rbp),%rsi
lea    0xeb3(%rip),%rdi
call   1040 <scanf@plt>
lea    -0x80(%rbp),%rdi
call   1050 <str_len@plt>
mov    %eax,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
cmp    %ecx,%eax
jge    11f8 <main+0xc8>
movslq -0xc(%rbp),%rax
movsbl -0x80(%rbp,%rax,1),%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
add    %ecx,%eax
cltq
mov    -0x80(%rbp,%rax,1),%cl
movslq -0xc(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
mov    %al,%cl
mov    -0xc(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x88(%rbp),%eax
add    %edx,%eax
cltq
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1165 <main+0x35>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
cmp    %ecx,%eax
jge    1298 <main+0x168>
movslq -0xc(%rbp),%rax
movsbl -0x80(%rbp,%rax,1),%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
add    %ecx,%eax
add    $0x1,%eax
cltq
mov    -0x80(%rbp,%rax,1),%cl
movslq -0xc(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
mov    %al,%cl
mov    -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x94(%rbp),%eax
add    %edx,%eax
add    $0x1,%eax
cltq
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11ff <main+0xcf>
lea    -0x80(%rbp),%rsi
lea    0xd5d(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x68,%rsp
lea    0xec2(%rip),%rdi
mov    %rsp,%r14
mov    %r14,%rsi
call   1040 <scanf@plt>
mov    %r14,%rdi
call   1050 <str_len@plt>
cmp    $0x2,%eax
jl     129c <main+0x16c>
mov    %eax,%r9d
shr    $0x1f,%r9d
add    %eax,%r9d
sar    %r9d
movslq %r9d,%r10
mov    %r10d,%r11d
cmp    $0x8,%r10d
jb     1194 <main+0x64>
lea    (%r10,%r11,1),%rdx
add    %rsp,%rdx
cmp    %rdx,%r14
jae    12b5 <main+0x185>
lea    (%rsp,%r11,1),%rdx
lea    (%rsp,%r10,1),%rsi
cmp    %rdx,%rsi
jae    12b5 <main+0x185>
xor    %edi,%edi
mov    %rdi,%rdx
not    %rdx
test   $0x1,%r11b
je     11b6 <main+0x86>
mov    (%rsp,%rdi,1),%cl
lea    (%rdi,%r10,1),%rsi
mov    (%rsp,%rsi,1),%bl
mov    %bl,(%rsp,%rdi,1)
mov    %cl,(%rsp,%rsi,1)
or     $0x1,%rdi
add    %r11,%rdx
je     11f9 <main+0xc9>
lea    (%r10,%r14,1),%rdx
add    $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rsp,%rdi,1),%ecx
movzbl -0x1(%rdx,%rdi,1),%ebx
mov    %bl,(%rsp,%rdi,1)
mov    %cl,-0x1(%rdx,%rdi,1)
movzbl 0x1(%rsp,%rdi,1),%ecx
movzbl (%rdx,%rdi,1),%ebx
mov    %bl,0x1(%rsp,%rdi,1)
mov    %cl,(%rdx,%rdi,1)
add    $0x2,%rdi
cmp    %rdi,%r11
jne    11d0 <main+0xa0>
cmp    $0x2,%eax
jl     129c <main+0x16c>
cmp    $0x8,%r9d
jb     1231 <main+0x101>
lea    (%r10,%r14,1),%rdi
add    $0x1,%rdi
lea    (%r10,%r11,1),%rax
add    %rsp,%rax
add    $0x1,%rax
cmp    %rax,%r14
jae    12c2 <main+0x192>
lea    (%rsp,%r11,1),%rax
cmp    %rax,%rdi
jae    12c2 <main+0x192>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
test   $0x1,%r11b
je     1259 <main+0x129>
mov    (%rsp,%rax,1),%cl
mov    %rax,%rsi
or     $0x1,%rsi
lea    (%rsi,%r10,1),%rdi
mov    (%rsp,%rdi,1),%bl
mov    %bl,(%rsp,%rax,1)
mov    %cl,(%rsp,%rdi,1)
mov    %rsi,%rax
add    %r11,%rdx
je     129c <main+0x16c>
lea    (%r10,%r14,1),%rdx
add    $0x2,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rsp,%rax,1),%ecx
movzbl -0x1(%rdx,%rax,1),%ebx
mov    %bl,(%rsp,%rax,1)
mov    %cl,-0x1(%rdx,%rax,1)
movzbl 0x1(%rsp,%rax,1),%ecx
movzbl (%rdx,%rax,1),%ebx
mov    %bl,0x1(%rsp,%rax,1)
mov    %cl,(%rdx,%rax,1)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r11
jne    1270 <main+0x140>
lea    0xd5d(%rip),%rdi
mov    %rsp,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r9d
jae    12d3 <main+0x1a3>
xor    %edi,%edi
jmp    13a7 <main+0x277>
cmp    $0x20,%r9d
jae    13e6 <main+0x2b6>
xor    %eax,%eax
jmp    14d2 <main+0x3a2>
mov    %r11d,%edi
and    $0xffffffe0,%edi
lea    -0x20(%rdi),%rdx
mov    %rdx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1478 <main+0x348>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rsp,%r10,1),%rdx
add    $0x30,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps (%rsp,%rbx,1),%xmm0
movaps 0x10(%rsp,%rbx,1),%xmm1
movups -0x30(%rdx,%rbx,1),%xmm2
movups -0x20(%rdx,%rbx,1),%xmm3
movaps %xmm2,(%rsp,%rbx,1)
movaps %xmm3,0x10(%rsp,%rbx,1)
movups %xmm0,-0x30(%rdx,%rbx,1)
movups %xmm1,-0x20(%rdx,%rbx,1)
movaps 0x20(%rsp,%rbx,1),%xmm0
movaps 0x30(%rsp,%rbx,1),%xmm1
movups -0x10(%rdx,%rbx,1),%xmm2
movups (%rdx,%rbx,1),%xmm3
movaps %xmm2,0x20(%rsp,%rbx,1)
movaps %xmm3,0x30(%rsp,%rbx,1)
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1310 <main+0x1e0>
test   $0x1,%r8b
je     1394 <main+0x264>
movaps (%rsp,%rbx,1),%xmm0
movaps 0x10(%rsp,%rbx,1),%xmm1
lea    (%rbx,%r10,1),%rdx
movups (%rsp,%rdx,1),%xmm2
movups 0x10(%rsp,%rdx,1),%xmm3
movaps %xmm2,(%rsp,%rbx,1)
movaps %xmm3,0x10(%rsp,%rbx,1)
movups %xmm0,(%rsp,%rdx,1)
movups %xmm1,0x10(%rsp,%rdx,1)
cmp    %r11,%rdi
je     11f9 <main+0xc9>
test   $0x18,%r11b
je     1196 <main+0x66>
mov    %rdi,%rdx
mov    %r11d,%edi
and    $0xfffffff8,%edi
lea    (%rsp,%rdx,1),%rsi
sub    %rdi,%rdx
nopw   0x0(%rax,%rax,1)
mov    (%rsi),%rbx
mov    (%rsi,%r10,1),%rcx
mov    %rcx,(%rsi)
mov    %rbx,(%rsi,%r10,1)
add    $0x8,%rsi
add    $0x8,%rdx
jne    13c0 <main+0x290>
cmp    %r11,%rdi
je     11f9 <main+0xc9>
jmp    1196 <main+0x66>
mov    %r11d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1489 <main+0x359>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r10,%r14,1),%rdx
add    $0x31,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movaps (%rsp,%rsi,1),%xmm0
movaps 0x10(%rsp,%rsi,1),%xmm1
movups -0x30(%rdx,%rsi,1),%xmm2
movups -0x20(%rdx,%rsi,1),%xmm3
movaps %xmm2,(%rsp,%rsi,1)
movaps %xmm3,0x10(%rsp,%rsi,1)
movups %xmm0,-0x30(%rdx,%rsi,1)
movups %xmm1,-0x20(%rdx,%rsi,1)
movaps 0x20(%rsp,%rsi,1),%xmm0
movaps 0x30(%rsp,%rsi,1),%xmm1
movups -0x10(%rdx,%rsi,1),%xmm2
movups (%rdx,%rsi,1),%xmm3
movaps %xmm2,0x20(%rsp,%rsi,1)
movaps %xmm3,0x30(%rsp,%rsi,1)
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1420 <main+0x2f0>
jmp    148b <main+0x35b>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    136c <main+0x23c>
jmp    1394 <main+0x264>
xor    %esi,%esi
test   $0x1,%r8b
je     14bf <main+0x38f>
movaps (%rsp,%rsi,1),%xmm0
movaps 0x10(%rsp,%rsi,1),%xmm1
mov    %rsi,%rcx
or     $0x1,%rcx
add    %r10,%rcx
movups (%rsp,%rcx,1),%xmm2
movups 0x10(%rsp,%rcx,1),%xmm3
movaps %xmm2,(%rsp,%rsi,1)
movaps %xmm3,0x10(%rsp,%rsi,1)
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %r11,%rax
je     129c <main+0x16c>
test   $0x18,%r11b
je     1233 <main+0x103>
mov    %rax,%rdx
mov    %r11d,%eax
and    $0xfffffff8,%eax
nopl   0x0(%rax,%rax,1)
mov    (%rsp,%rdx,1),%rcx
mov    (%rdi,%rdx,1),%rsi
mov    %rsi,(%rsp,%rdx,1)
mov    %rcx,(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    14e0 <main+0x3b0>
cmp    %r11,%rax
je     129c <main+0x16c>
jmp    1233 <main+0x103>

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

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