#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*/ encrypt(unsigned char **, unsigned char *, unsigned int);
int /*<<< orphan*/ free(unsigned char *);
unsigned char *malloc(int);
scalar_t__ strncmp(char *, char *, unsigned int);
unsigned char detect_byte(unsigned char *partial_decoding,
                          unsigned int prefix_len, unsigned int byte_idx,
                          unsigned int block_idx, unsigned int block_size) {
  unsigned char *plain, *cipher, *candidate, i, byte;
  unsigned int padded_prefix_len = prefix_len;
  if (prefix_len % block_size)
    padded_prefix_len = prefix_len + block_size - (prefix_len % block_size);
  unsigned int pad_fill_len = 0;
  if (prefix_len % block_size)
    pad_fill_len = block_size - (prefix_len % block_size);
  plain = malloc(sizeof(unsigned char) *
                 ((prefix_len % block_size) + block_size * (block_idx + 1)));
  if (NULL == plain)
    return 0x00;
  for (i = 0; i < pad_fill_len; i++)
    plain[i] = 'P';
  for (i = 0; i < block_size - 1 - byte_idx; i++)
    plain[(prefix_len % block_size) + i] = 'A';
  encrypt(&cipher, plain, pad_fill_len + block_size - byte_idx - 1);
  for (i = block_size - 1 - byte_idx; i < block_size * (block_idx + 1) - 1; i++)
    plain[pad_fill_len + i] = partial_decoding[i - (block_size - 1 - byte_idx)];
  for (byte = 0; byte < 255; byte++) {
    plain[pad_fill_len + block_size * (block_idx + 1) - 1] = byte;
    encrypt(&candidate, plain, pad_fill_len + block_size * (block_idx + 1));
    if (0 ==
        strncmp((char *)candidate + padded_prefix_len + block_size * block_idx,
                (char *)cipher + padded_prefix_len + block_size * block_idx,
                block_size)) {
      free(candidate);
      break;
    }
    free(candidate);
  }
  free(plain);
  free(cipher);
  return byte;
}


x86 assembly (clang, -O0):
<detect_byte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
cmp    $0x0,%edx
je     1189 <detect_byte+0x49>
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
mov    -0x48(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
cmp    $0x0,%edx
je     11b7 <detect_byte+0x77>
mov    -0x20(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
mov    -0x4c(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    %eax,%edx
mov    %edx,%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
xor    %eax,%eax
cmp    -0x28(%rbp),%rax
jne    11f3 <detect_byte+0xb3>
movb   $0x0,-0x1(%rbp)
jmp    13a9 <detect_byte+0x269>
movb   $0x0,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    121d <detect_byte+0xdd>
mov    -0x28(%rbp),%rax
movzbl -0x39(%rbp),%ecx
movb   $0x50,(%rax,%rcx,1)
mov    -0x39(%rbp),%al
add    $0x1,%al
mov    %al,-0x39(%rbp)
jmp    11f7 <detect_byte+0xb7>
movb   $0x0,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jae    1263 <detect_byte+0x123>
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x20(%rbp)
mov    -0x58(%rbp),%rax
movzbl -0x39(%rbp),%ecx
add    %ecx,%edx
mov    %edx,%ecx
movb   $0x41,(%rax,%rcx,1)
mov    -0x39(%rbp),%al
add    $0x1,%al
mov    %al,-0x39(%rbp)
jmp    1221 <detect_byte+0xe1>
mov    -0x28(%rbp),%rsi
mov    -0x44(%rbp),%edx
add    -0x20(%rbp),%edx
sub    -0x18(%rbp),%edx
sub    $0x1,%edx
lea    -0x30(%rbp),%rdi
call   1050 <encrypt@plt>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
sub    -0x18(%rbp),%eax
mov    %al,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    12da <detect_byte+0x19a>
mov    -0x10(%rbp),%rax
movzbl -0x39(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
sub    -0x18(%rbp),%edx
sub    %edx,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
movzbl -0x39(%rbp),%esi
add    %esi,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x39(%rbp),%al
add    $0x1,%al
mov    %al,-0x39(%rbp)
jmp    1288 <detect_byte+0x148>
movb   $0x0,-0x3a(%rbp)
movzbl -0x3a(%rbp),%eax
cmp    $0xff,%eax
jge    1391 <detect_byte+0x251>
mov    -0x3a(%rbp),%dl
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    %eax,%edx
lea    -0x38(%rbp),%rdi
call   1050 <encrypt@plt>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%eax
add    %rax,%rdi
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,%eax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x40(%rbp),%eax
add    %rax,%rsi
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,%eax
add    %rax,%rsi
mov    -0x20(%rbp),%edx
call   1040 <strncmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
jne    137b <detect_byte+0x23b>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
jmp    1391 <detect_byte+0x251>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x3a(%rbp),%al
add    $0x1,%al
mov    %al,-0x3a(%rbp)
jmp    12de <detect_byte+0x19e>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x3a(%rbp),%al
mov    %al,-0x1(%rbp)
movzbl -0x1(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<detect_byte>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,0x1c(%rsp)
mov    %esi,%eax
xor    %edx,%edx
div    %r8d
mov    %edx,%r13d
xor    %ebp,%ebp
lea    (%r8,%rsi,1),%ebx
sub    %edx,%ebx
mov    %r8d,%r14d
sub    %edx,%r14d
test   %edx,%edx
cmove  %esi,%ebx
cmove  %edx,%r14d
mov    %rdi,%r15
mov    %rcx,0x10(%rsp)
lea    0x1(%rcx),%eax
mov    %r8,0x8(%rsp)
imul   %r8d,%eax
mov    %rax,0x30(%rsp)
lea    (%rax,%r13,1),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1559 <detect_byte+0x419>
mov    %rax,%r12
test   %r14d,%r14d
je     12e3 <detect_byte+0x1a3>
cmp    $0x8,%r14d
jae    11b7 <detect_byte+0x77>
xor    %ecx,%ecx
jmp    12d0 <detect_byte+0x190>
lea    -0x1(%r14),%eax
xor    %ecx,%ecx
cmp    $0xff,%al
je     12d0 <detect_byte+0x190>
cmp    $0xff,%eax
ja     12d0 <detect_byte+0x190>
xor    %eax,%eax
cmp    $0x20,%r14d
jb     129e <detect_byte+0x15e>
mov    %r14d,%eax
and    $0xffffffe0,%eax
movaps 0xe17(%rip),%xmm0
movups %xmm0,(%r12)
movups %xmm0,0x10(%r12)
cmp    $0x20,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0x20(%r12)
movups %xmm0,0x30(%r12)
cmp    $0x40,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0x40(%r12)
movups %xmm0,0x50(%r12)
cmp    $0x60,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0x60(%r12)
movups %xmm0,0x70(%r12)
cmp    $0x80,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0x80(%r12)
movups %xmm0,0x90(%r12)
cmp    $0xa0,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0xa0(%r12)
movups %xmm0,0xb0(%r12)
cmp    $0xc0,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0xc0(%r12)
movups %xmm0,0xd0(%r12)
cmp    $0xe0,%eax
je     1293 <detect_byte+0x153>
movups %xmm0,0xe0(%r12)
movups %xmm0,0xf0(%r12)
cmp    %eax,%r14d
je     12e3 <detect_byte+0x1a3>
test   $0x18,%r14b
je     12ca <detect_byte+0x18a>
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
movabs $0x5050505050505050,%rdx
50 50 50
xchg   %ax,%ax
mov    %eax,%esi
and    $0xf8,%esi
mov    %rdx,(%r12,%rsi,1)
add    $0x8,%eax
cmp    %eax,%ecx
jne    12b0 <detect_byte+0x170>
cmp    %ecx,%r14d
jne    12d0 <detect_byte+0x190>
jmp    12e3 <detect_byte+0x1a3>
mov    %eax,%ecx
nopl   0x0(%rax)
movzbl %cl,%ecx
movb   $0x50,(%r12,%rcx,1)
add    $0x1,%cl
movzbl %cl,%eax
cmp    %eax,%r14d
ja     12d0 <detect_byte+0x190>
mov    0x1c(%rsp),%eax
mov    %eax,%ebp
not    %ebp
add    0x8(%rsp),%ebp
je     1487 <detect_byte+0x347>
mov    0x8(%rsp),%r9
sub    %eax,%r9d
add    $0xfffffffe,%r9d
cmp    $0x7,%r9d
jae    1310 <detect_byte+0x1d0>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    145e <detect_byte+0x31e>
mov    %r13d,%eax
add    %r9d,%eax
setb   %dl
xor    %eax,%eax
cmp    $0xff,%r9b
je     137b <detect_byte+0x23b>
cmp    $0xff,%r9d
ja     137b <detect_byte+0x23b>
mov    $0x0,%ecx
test   %dl,%dl
jne    145e <detect_byte+0x31e>
movabs $0x1ffffffe0,%rax
cmp    $0x1f,%r9d
jae    134e <detect_byte+0x20e>
xor    %ecx,%ecx
jmp    1417 <detect_byte+0x2d7>
mov    %ebx,%r11d
lea    0x1(%r9),%r8
mov    %r8,%rcx
and    %rax,%rcx
lea    -0x20(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rsi
jae    1382 <detect_byte+0x242>
xor    %edx,%edx
jmp    13e2 <detect_byte+0x2a2>
xor    %ecx,%ecx
jmp    145e <detect_byte+0x31e>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
movaps 0xc81(%rip),%xmm0
nop
lea    (%rdx,%r13,1),%ebx
movups %xmm0,(%r12,%rbx,1)
movups %xmm0,0x10(%r12,%rbx,1)
mov    %edx,%esi
or     $0x20,%esi
add    %r13d,%esi
movups %xmm0,(%r12,%rsi,1)
movups %xmm0,0x10(%r12,%rsi,1)
mov    %edx,%esi
or     $0x40,%esi
add    %r13d,%esi
movups %xmm0,(%r12,%rsi,1)
movups %xmm0,0x10(%r12,%rsi,1)
mov    %edx,%esi
or     $0x60,%esi
add    %r13d,%esi
movups %xmm0,(%r12,%rsi,1)
movups %xmm0,0x10(%r12,%rsi,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1390 <detect_byte+0x250>
test   %r10,%r10
je     1409 <detect_byte+0x2c9>
movaps 0xc22(%rip),%xmm0
xchg   %ax,%ax
lea    (%rdx,%r13,1),%esi
movups %xmm0,(%r12,%rsi,1)
movups %xmm0,0x10(%r12,%rsi,1)
add    $0x20,%rdx
add    $0xffffffffffffffff,%r10
jne    13f0 <detect_byte+0x2b0>
cmp    %rcx,%r8
mov    %r11d,%ebx
je     1487 <detect_byte+0x347>
test   $0x18,%r8b
je     145c <detect_byte+0x31c>
add    $0x1,%r9
add    $0x18,%rax
and    %r9,%rax
mov    %rcx,%rdx
sub    %rax,%rdx
movabs $0x4141414141414141,%rsi
41 41 41
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%r13,1),%edi
mov    %rsi,(%r12,%rdi,1)
add    $0x8,%rcx
add    $0x8,%rdx
jne    1440 <detect_byte+0x300>
mov    %rax,%rcx
cmp    %rax,%r9
jne    145e <detect_byte+0x31e>
jmp    1487 <detect_byte+0x347>
mov    %ecx,%eax
add    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r13,1),%edx
movb   $0x41,(%r12,%rdx,1)
movzbl %al,%edx
add    $0x1,%rcx
add    $0x1,%eax
cmp    %edx,%ebp
ja     1470 <detect_byte+0x330>
mov    %ebx,%r13d
lea    (%r14,%rbp,1),%edx
lea    0x28(%rsp),%rdi
mov    %r12,%rsi
call   1050 <encrypt@plt>
mov    0x30(%rsp),%rdi
lea    -0x1(%rdi),%eax
movzbl %bpl,%ecx
cmp    %ecx,%eax
jbe    14cb <detect_byte+0x38b>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%edx
sub    %ebp,%edx
movzbl (%r15,%rdx,1),%edx
lea    (%rcx,%r14,1),%esi
mov    %dl,(%r12,%rsi,1)
add    $0x1,%ecx
movzbl %cl,%ecx
cmp    %ecx,%eax
ja     14b0 <detect_byte+0x370>
lea    (%r14,%rdi,1),%ebx
lea    (%r14,%rdi,1),%r15d
add    $0xffffffff,%r15d
mov    %r13d,%r13d
mov    0x10(%rsp),%rax
imul   0x8(%rsp),%eax
mov    %rax,0x10(%rsp)
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %bpl,(%r12,%r15,1)
lea    0x20(%rsp),%rdi
mov    %r12,%rsi
mov    %ebx,%edx
call   1050 <encrypt@plt>
mov    0x20(%rsp),%rdi
add    %r13,%rdi
mov    0x10(%rsp),%rax
add    %rax,%rdi
mov    0x28(%rsp),%rsi
add    %r13,%rsi
add    %rax,%rsi
mov    0x8(%rsp),%rdx
call   1040 <strncmp@plt>
mov    %rax,%r14
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
test   %r14,%r14
je     1547 <detect_byte+0x407>
add    $0x1,%bpl
cmp    $0xff,%bpl
jne    14f0 <detect_byte+0x3b0>
mov    $0xff,%bpl
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define zeroext i8 @detect_byte(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i8
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8
%16 = alloca i8
%17 = alloca i32
%18 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
%19 = load i32, i32* %8
store i32 %19, i32* %17
%20 = load i32, i32* %8
%21 = load i32, i32* %11
%22 = urem i32 %20, %21
%23 = icmp ne i32 %22, 0
br i1 %23, label %24, label %32
24: ; preds = %5
%25 = load i32, i32* %8
%26 = load i32, i32* %11
%27 = add i32 %25, %26
%28 = load i32, i32* %8
%29 = load i32, i32* %11
%30 = urem i32 %28, %29
%31 = sub i32 %27, %30
store i32 %31, i32* %17
br label %32
32: ; preds = %24, %5
store i32 0, i32* %18
%33 = load i32, i32* %8
%34 = load i32, i32* %11
%35 = urem i32 %33, %34
%36 = icmp ne i32 %35, 0
br i1 %36, label %37, label %43
37: ; preds = %32
%38 = load i32, i32* %11
%39 = load i32, i32* %8
%40 = load i32, i32* %11
%41 = urem i32 %39, %40
%42 = sub i32 %38, %41
store i32 %42, i32* %18
br label %43
43: ; preds = %37, %32
%44 = load i32, i32* %8
%45 = load i32, i32* %11
%46 = urem i32 %44, %45
%47 = load i32, i32* %11
%48 = load i32, i32* %10
%49 = add i32 %48, 1
%50 = mul i32 %47, %49
%51 = add i32 %46, %50
%52 = zext i32 %51 to i64
%53 = mul i64 1, %52
%54 = trunc i64 %53 to i32
%55 = call i8* @malloc(i32 %54)
store i8* %55, i8** %12
%56 = load i8*, i8** %12
%57 = icmp eq i8* null, %56
br i1 %57, label %58, label %59
58: ; preds = %43
store i8 0, i8* %6
br label %201
59: ; preds = %43
store i8 0, i8* %15
br label %60
60: ; preds = %70, %59
%61 = load i8, i8* %15
%62 = zext i8 %61 to i32
%63 = load i32, i32* %18
%64 = icmp ult i32 %62, %63
br i1 %64, label %65, label %73
65: ; preds = %60
%66 = load i8*, i8** %12
%67 = load i8, i8* %15
%68 = zext i8 %67 to i64
%69 = getelementptr inbounds i8, i8* %66, i64 %68
store i8 80, i8* %69
br label %70
70: ; preds = %65
%71 = load i8, i8* %15
%72 = add i8 %71, 1
store i8 %72, i8* %15
br label %60
73: ; preds = %60
store i8 0, i8* %15
br label %74
74: ; preds = %92, %73
%75 = load i8, i8* %15
%76 = zext i8 %75 to i32
%77 = load i32, i32* %11
%78 = sub i32 %77, 1
%79 = load i32, i32* %9
%80 = sub i32 %78, %79
%81 = icmp ult i32 %76, %80
br i1 %81, label %82, label %95
82: ; preds = %74
%83 = load i8*, i8** %12
%84 = load i32, i32* %8
%85 = load i32, i32* %11
%86 = urem i32 %84, %85
%87 = load i8, i8* %15
%88 = zext i8 %87 to i32
%89 = add i32 %86, %88
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %83, i64 %90
store i8 65, i8* %91
br label %92
92: ; preds = %82
%93 = load i8, i8* %15
%94 = add i8 %93, 1
store i8 %94, i8* %15
br label %74
95: ; preds = %74
%96 = load i8*, i8** %12
%97 = load i32, i32* %18
%98 = load i32, i32* %11
%99 = add i32 %97, %98
%100 = load i32, i32* %9
%101 = sub i32 %99, %100
%102 = sub i32 %101, 1
%103 = call i32 @encrypt(i8** %13, i8* %96, i32 %102)
%104 = load i32, i32* %11
%105 = sub i32 %104, 1
%106 = load i32, i32* %9
%107 = sub i32 %105, %106
%108 = trunc i32 %107 to i8
store i8 %108, i8* %15
br label %109
109: ; preds = %137, %95
%110 = load i8, i8* %15
%111 = zext i8 %110 to i32
%112 = load i32, i32* %11
%113 = load i32, i32* %10
%114 = add i32 %113, 1
%115 = mul i32 %112, %114
%116 = sub i32 %115, 1
%117 = icmp ult i32 %111, %116
br i1 %117, label %118, label %140
118: ; preds = %109
%119 = load i8*, i8** %7
%120 = load i8, i8* %15
%121 = zext i8 %120 to i32
%122 = load i32, i32* %11
%123 = sub i32 %122, 1
%124 = load i32, i32* %9
%125 = sub i32 %123, %124
%126 = sub i32 %121, %125
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %119, i64 %127
%129 = load i8, i8* %128
%130 = load i8*, i8** %12
%131 = load i32, i32* %18
%132 = load i8, i8* %15
%133 = zext i8 %132 to i32
%134 = add i32 %131, %133
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %130, i64 %135
store i8 %129, i8* %136
br label %137
137: ; preds = %118
%138 = load i8, i8* %15
%139 = add i8 %138, 1
store i8 %139, i8* %15
br label %109
140: ; preds = %109
store i8 0, i8* %16
br label %141
141: ; preds = %192, %140
%142 = load i8, i8* %16
%143 = zext i8 %142 to i32
%144 = icmp slt i32 %143, 255
br i1 %144, label %145, label %195
145: ; preds = %141
%146 = load i8, i8* %16
%147 = load i8*, i8** %12
%148 = load i32, i32* %18
%149 = load i32, i32* %11
%150 = load i32, i32* %10
%151 = add i32 %150, 1
%152 = mul i32 %149, %151
%153 = add i32 %148, %152
%154 = sub i32 %153, 1
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %147, i64 %155
store i8 %146, i8* %156
%157 = load i8*, i8** %12
%158 = load i32, i32* %18
%159 = load i32, i32* %11
%160 = load i32, i32* %10
%161 = add i32 %160, 1
%162 = mul i32 %159, %161
%163 = add i32 %158, %162
%164 = call i32 @encrypt(i8** %14, i8* %157, i32 %163)
%165 = load i8*, i8** %14
%166 = load i32, i32* %17
%167 = zext i32 %166 to i64
%168 = getelementptr inbounds i8, i8* %165, i64 %167
%169 = load i32, i32* %11
%170 = load i32, i32* %10
%171 = mul i32 %169, %170
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds i8, i8* %168, i64 %172
%174 = load i8*, i8** %13
%175 = load i32, i32* %17
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %174, i64 %176
%178 = load i32, i32* %11
%179 = load i32, i32* %10
%180 = mul i32 %178, %179
%181 = zext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %177, i64 %181
%183 = load i32, i32* %11
%184 = call i64 @strncmp(i8* %173, i8* %182, i32 %183)
%185 = icmp eq i64 0, %184
br i1 %185, label %186, label %189
186: ; preds = %145
%187 = load i8*, i8** %14
%188 = call i32 @free(i8* %187)
br label %195
189: ; preds = %145
%190 = load i8*, i8** %14
%191 = call i32 @free(i8* %190)
br label %192
192: ; preds = %189
%193 = load i8, i8* %16
%194 = add i8 %193, 1
store i8 %194, i8* %16
br label %141
195: ; preds = %186, %141
%196 = load i8*, i8** %12
%197 = call i32 @free(i8* %196)
%198 = load i8*, i8** %13
%199 = call i32 @free(i8* %198)
%200 = load i8, i8* %16
store i8 %200, i8* %6
br label %201
201: ; preds = %195, %58
%202 = load i8, i8* %6
ret i8 %202
}

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