#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*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memset(char *, int, int);
scalar_t__ pow(int, int);
void reduce(char *plain, char *cipher, int mask, int length, int pLen, int i,
            int kk) {
  kk = kk % 8;
  int s = i * 4 % 13;
  int m = (8 - pLen) % 8;
  int r = i % mask;
  s = (int)pow(s, 23) % 13;
  m = m < 0 ? m + 8 : m;
  r = r < 0 ? r + mask : r;
  memset(plain, 0x0, length);
  memcpy(plain, cipher + r, length);
  memcpy(plain, cipher, length / 2);
  for (int k = 0; k < length; k++) {
    plain[k] = plain[k] ^ i;
  }
  for (int k = 0; k < length; k++) {
    plain[k] = plain[k] ^ (1 * s);
  }
  for (int k = 0; k < length; k++) {
    plain[k] = plain[k] ^ (13 * kk);
  }
  plain[0] = plain[0] & (0xFFU >> m);
}


x86 assembly (clang, -O0):
<reduce>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    0x10(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,0x10(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x2,%eax
mov    $0xd,%ecx
cltd
idiv   %ecx
mov    %edx,-0x24(%rbp)
mov    $0x8,%eax
sub    -0x1c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x28(%rbp)
mov    -0x20(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x2c(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x17,%esi
call   1050 <pow@plt>
mov    $0xd,%ecx
cltd
idiv   %ecx
mov    %edx,-0x24(%rbp)
cmpl   $0x0,-0x28(%rbp)
jge    11bd <reduce+0x8d>
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c3 <reduce+0x93>
mov    -0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    11e1 <reduce+0xb1>
mov    -0x2c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    11e7 <reduce+0xb7>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x2c(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1269 <reduce+0x139>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
xor    -0x20(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1233 <reduce+0x103>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12ab <reduce+0x17b>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x24(%rbp),%ecx
shl    $0x0,%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1270 <reduce+0x140>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12eb <reduce+0x1bb>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
imul   $0xd,0x10(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12b2 <reduce+0x182>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    -0x28(%rbp),%ecx
mov    $0xff,%edx
shr    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reduce>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,%r13d
mov    %ecx,%r12d
mov    %edx,%ebp
mov    %rsi,0x18(%rsp)
mov    %rdi,%rbx
mov    0x60(%rsp),%eax
lea    0x7(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,0xc(%rsp)
lea    0x0(,%r13,4),%eax
movslq %eax,%rdi
imul   $0x4ec4ec4f,%rdi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
lea    (%rax,%rax,2),%ecx
lea    (%rax,%rcx,4),%eax
sub    %eax,%edi
mov    $0x8,%ecx
sub    %r8d,%ecx
mov    $0xf,%eax
sub    %r8d,%eax
test   %ecx,%ecx
cmovns %ecx,%eax
and    $0xfffffff8,%eax
sub    %eax,%ecx
mov    %rcx,0x20(%rsp)
mov    %r9d,%eax
cltd
idiv   %ebp
mov    %edx,%r14d
mov    $0x17,%esi
call   1050 <pow@plt>
mov    %rax,0x10(%rsp)
mov    %r14d,%r15d
sar    $0x1f,%r15d
and    %ebp,%r15d
add    %r14d,%r15d
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1030 <memset@plt>
movslq %r15d,%rsi
mov    0x18(%rsp),%rbp
add    %rbp,%rsi
mov    %rbx,%rdi
mov    %r12d,%edx
call   1040 <memcpy@plt>
mov    %r12d,%edx
shr    $0x1f,%edx
add    %r12d,%edx
sar    %edx
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <memcpy@plt>
test   %r12d,%r12d
jle    15ac <reduce+0x47c>
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    121b <reduce+0xeb>
xor    %ecx,%ecx
jmp    1320 <reduce+0x1f0>
movzbl %r13b,%r8d
cmp    $0x20,%r12d
jae    122c <reduce+0xfc>
xor    %ecx,%ecx
jmp    12e4 <reduce+0x1b4>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     15d4 <reduce+0x4a4>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rbx,%rsi,1),%xmm1
movdqu 0x10(%rbx,%rsi,1),%xmm2
movdqu 0x20(%rbx,%rsi,1),%xmm3
movdqu 0x30(%rbx,%rsi,1),%xmm4
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rsi,1)
movdqu %xmm2,0x10(%rbx,%rsi,1)
pxor   %xmm0,%xmm3
pxor   %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rsi,1)
movdqu %xmm4,0x30(%rbx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1270 <reduce+0x140>
test   $0x1,%dl
je     12db <reduce+0x1ab>
movdqu (%rbx,%rsi,1),%xmm1
movdqu 0x10(%rbx,%rsi,1),%xmm2
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rsi,1)
movdqu %xmm2,0x10(%rbx,%rsi,1)
cmp    %rax,%rcx
je     132d <reduce+0x1fd>
test   $0x18,%al
je     1320 <reduce+0x1f0>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movq   (%rbx,%rdx,1),%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1300 <reduce+0x1d0>
cmp    %rax,%rcx
je     132d <reduce+0x1fd>
nopl   0x0(%rax)
xor    %r13b,(%rbx,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1320 <reduce+0x1f0>
test   %r12d,%r12d
jle    15ac <reduce+0x47c>
movslq 0x10(%rsp),%rcx
imul   $0x4ec4ec4f,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x22,%rdx
add    %esi,%edx
lea    (%rdx,%rdx,2),%esi
lea    (%rdx,%rsi,4),%edx
sub    %edx,%ecx
cmp    $0x8,%r12d
jae    1364 <reduce+0x234>
xor    %edx,%edx
jmp    1460 <reduce+0x330>
movzbl %cl,%r8d
cmp    $0x20,%r12d
jae    1375 <reduce+0x245>
xor    %edx,%edx
jmp    1425 <reduce+0x2f5>
mov    %eax,%edx
and    $0xffffffe0,%edx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     15e4 <reduce+0x4b4>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
xchg   %ax,%ax
movdqu (%rbx,%rdi,1),%xmm1
movdqu 0x10(%rbx,%rdi,1),%xmm2
movdqu 0x20(%rbx,%rdi,1),%xmm3
movdqu 0x30(%rbx,%rdi,1),%xmm4
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,1)
movdqu %xmm2,0x10(%rbx,%rdi,1)
pxor   %xmm0,%xmm3
pxor   %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,1)
movdqu %xmm4,0x30(%rbx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbp
jne    13b0 <reduce+0x280>
test   $0x1,%sil
je     141c <reduce+0x2ec>
movdqu (%rbx,%rdi,1),%xmm1
movdqu 0x10(%rbx,%rdi,1),%xmm2
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,1)
movdqu %xmm2,0x10(%rbx,%rdi,1)
cmp    %rax,%rdx
je     146c <reduce+0x33c>
test   $0x18,%al
je     1460 <reduce+0x330>
mov    %rdx,%rsi
mov    %eax,%edx
and    $0xfffffff8,%edx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rsi,1),%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%rbx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1440 <reduce+0x310>
cmp    %rax,%rdx
je     146c <reduce+0x33c>
nopl   0x0(%rax)
xor    %cl,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1460 <reduce+0x330>
test   %r12d,%r12d
jle    15ac <reduce+0x47c>
mov    0xc(%rsp),%esi
and    $0xfffffff8,%esi
mov    0x60(%rsp),%ecx
mov    %rcx,%rdx
sub    %esi,%edx
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rcx,4),%ecx
cmp    $0x8,%r12d
jae    1498 <reduce+0x368>
xor    %edx,%edx
jmp    15a0 <reduce+0x470>
movzbl %cl,%r8d
cmp    $0x20,%r12d
jae    14a9 <reduce+0x379>
xor    %edx,%edx
jmp    1565 <reduce+0x435>
mov    %eax,%edx
and    $0xffffffe0,%edx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     15f5 <reduce+0x4c5>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rbx,%rdi,1),%xmm1
movdqu 0x10(%rbx,%rdi,1),%xmm2
movdqu 0x20(%rbx,%rdi,1),%xmm3
movdqu 0x30(%rbx,%rdi,1),%xmm4
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,1)
movdqu %xmm2,0x10(%rbx,%rdi,1)
pxor   %xmm0,%xmm3
pxor   %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,1)
movdqu %xmm4,0x30(%rbx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14f0 <reduce+0x3c0>
test   $0x1,%sil
je     155c <reduce+0x42c>
movdqu (%rbx,%rdi,1),%xmm1
movdqu 0x10(%rbx,%rdi,1),%xmm2
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,1)
movdqu %xmm2,0x10(%rbx,%rdi,1)
cmp    %rax,%rdx
je     15ac <reduce+0x47c>
test   $0x18,%al
je     15a0 <reduce+0x470>
mov    %rdx,%rsi
mov    %eax,%edx
and    $0xfffffff8,%edx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rsi,1),%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%rbx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1580 <reduce+0x450>
cmp    %rax,%rdx
je     15ac <reduce+0x47c>
nopl   0x0(%rax)
xor    %cl,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    15a0 <reduce+0x470>
mov    0x20(%rsp),%rdx
lea    0x8(%rdx),%eax
test   %edx,%edx
movzbl %al,%ecx
cmovns %edx,%ecx
mov    $0xff,%eax
shr    %cl,%eax
and    %al,(%rbx)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    12bd <reduce+0x18d>
jmp    12db <reduce+0x1ab>
xor    %edi,%edi
test   $0x1,%sil
jne    13fe <reduce+0x2ce>
jmp    141c <reduce+0x2ec>
xor    %edi,%edi
test   $0x1,%sil
jne    153e <reduce+0x40e>
jmp    155c <reduce+0x42c>

LLVM IR (-O0):
define void @reduce(i8* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i8* %0, i8** %8
store i8* %1, i8** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%21 = load i32, i32* %14
%22 = srem i32 %21, 8
store i32 %22, i32* %14
%23 = load i32, i32* %13
%24 = mul nsw i32 %23, 4
%25 = srem i32 %24, 13
store i32 %25, i32* %15
%26 = load i32, i32* %12
%27 = sub nsw i32 8, %26
%28 = srem i32 %27, 8
store i32 %28, i32* %16
%29 = load i32, i32* %13
%30 = load i32, i32* %10
%31 = srem i32 %29, %30
store i32 %31, i32* %17
%32 = load i32, i32* %15
%33 = call i64 @pow(i32 %32, i32 23)
%34 = trunc i64 %33 to i32
%35 = srem i32 %34, 13
store i32 %35, i32* %15
%36 = load i32, i32* %16
%37 = icmp slt i32 %36, 0
br i1 %37, label %38, label %41
38: ; preds = %7
%39 = load i32, i32* %16
%40 = add nsw i32 %39, 8
br label %43
41: ; preds = %7
%42 = load i32, i32* %16
br label %43
43: ; preds = %41, %38
%44 = phi i32 [ %40, %38 ], [ %42, %41 ]
store i32 %44, i32* %16
%45 = load i32, i32* %17
%46 = icmp slt i32 %45, 0
br i1 %46, label %47, label %51
47: ; preds = %43
%48 = load i32, i32* %17
%49 = load i32, i32* %10
%50 = add nsw i32 %48, %49
br label %53
51: ; preds = %43
%52 = load i32, i32* %17
br label %53
53: ; preds = %51, %47
%54 = phi i32 [ %50, %47 ], [ %52, %51 ]
store i32 %54, i32* %17
%55 = load i8*, i8** %8
%56 = load i32, i32* %11
%57 = call i32 @memset(i8* %55, i32 0, i32 %56)
%58 = load i8*, i8** %8
%59 = load i8*, i8** %9
%60 = load i32, i32* %17
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i32, i32* %11
%64 = call i32 @memcpy(i8* %58, i8* %62, i32 %63)
%65 = load i8*, i8** %8
%66 = load i8*, i8** %9
%67 = load i32, i32* %11
%68 = sdiv i32 %67, 2
%69 = call i32 @memcpy(i8* %65, i8* %66, i32 %68)
store i32 0, i32* %18
br label %70
70: ; preds = %88, %53
%71 = load i32, i32* %18
%72 = load i32, i32* %11
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %91
74: ; preds = %70
%75 = load i8*, i8** %8
%76 = load i32, i32* %18
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %75, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = load i32, i32* %13
%82 = xor i32 %80, %81
%83 = trunc i32 %82 to i8
%84 = load i8*, i8** %8
%85 = load i32, i32* %18
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
store i8 %83, i8* %87
br label %88
88: ; preds = %74
%89 = load i32, i32* %18
%90 = add nsw i32 %89, 1
store i32 %90, i32* %18
br label %70
91: ; preds = %70
store i32 0, i32* %19
br label %92
92: ; preds = %111, %91
%93 = load i32, i32* %19
%94 = load i32, i32* %11
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %114
96: ; preds = %92
%97 = load i8*, i8** %8
%98 = load i32, i32* %19
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = load i32, i32* %15
%104 = mul nsw i32 1, %103
%105 = xor i32 %102, %104
%106 = trunc i32 %105 to i8
%107 = load i8*, i8** %8
%108 = load i32, i32* %19
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
store i8 %106, i8* %110
br label %111
111: ; preds = %96
%112 = load i32, i32* %19
%113 = add nsw i32 %112, 1
store i32 %113, i32* %19
br label %92
114: ; preds = %92
store i32 0, i32* %20
br label %115
115: ; preds = %134, %114
%116 = load i32, i32* %20
%117 = load i32, i32* %11
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %137
119: ; preds = %115
%120 = load i8*, i8** %8
%121 = load i32, i32* %20
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %120, i64 %122
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = load i32, i32* %14
%127 = mul nsw i32 13, %126
%128 = xor i32 %125, %127
%129 = trunc i32 %128 to i8
%130 = load i8*, i8** %8
%131 = load i32, i32* %20
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %130, i64 %132
store i8 %129, i8* %133
br label %134
134: ; preds = %119
%135 = load i32, i32* %20
%136 = add nsw i32 %135, 1
store i32 %136, i32* %20
br label %115
137: ; preds = %115
%138 = load i8*, i8** %8
%139 = getelementptr inbounds i8, i8* %138, i64 0
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = load i32, i32* %16
%143 = lshr i32 255, %142
%144 = and i32 %141, %143
%145 = trunc i32 %144 to i8
%146 = load i8*, i8** %8
%147 = getelementptr inbounds i8, i8* %146, i64 0
store i8 %145, i8* %147
ret void
}

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