#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*/ memset(int *, int /*<<< orphan*/, int);
void rsencode(int nd, int nc, unsigned char *wd) {
  static int root[113 - 1] = {
      1,   3,   9,   27, 81,  17, 51, 40, 7,   21, 63,  76,  2,   6,
      18,  54,  49,  34, 102, 80, 14, 42, 13,  39, 4,   12,  36,  108,
      98,  68,  91,  47, 28,  84, 26, 78, 8,   24, 72,  103, 83,  23,
      69,  94,  56,  55, 52,  43, 16, 48, 31,  93, 53,  46,  25,  75,
      112, 110, 104, 86, 32,  96, 62, 73, 106, 92, 50,  37,  111, 107,
      95,  59,  64,  79, 11,  33, 99, 71, 100, 74, 109, 101, 77,  5,
      15,  45,  22,  66, 85,  29, 87, 35, 105, 89, 41,  10,  30,  90,
      44,  19,  57,  58, 61,  70, 97, 65, 82,  20, 60,  67,  88,  38};
  int i, j, k, nw, start, step, c[113];
  nw = nd + nc;
  step = (nw + 113 - 2) / (113 - 1);
  for (start = 0; start < step; start++) {
    int ND = (nd - start + step - 1) / step;
    int NW = (nw - start + step - 1) / step;
    int NC = NW - ND;
    memset(c, 0, 113 * sizeof(int));
    c[0] = 1;
    for (i = 1; i <= NC; i++) {
      for (j = NC; j >= 1; j--) {
        c[j] = (113 + c[j] - (root[i] * c[j - 1]) % 113) % 113;
      }
    }
    for (i = ND; i < NW; i++) {
      wd[start + i * step] = 0;
    }
    for (i = 0; i < ND; i++) {
      k = (wd[start + i * step] + wd[start + ND * step]) % 113;
      for (j = 0; j < NC - 1; j++) {
        wd[start + (ND + j) * step] =
            (113 - ((c[j + 1] * k) % 113) + wd[start + (ND + j + 1) * step]) %
            113;
      }
      wd[start + (ND + NC - 1) * step] = (113 - ((c[NC] * k) % 113)) % 113;
    }
    for (i = ND; i < NW; i++) {
      wd[start + i * step] = (113 - wd[start + i * step]) % 113;
    }
  }
}


x86 assembly (clang, -O0):
<rsencode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x71,%eax
sub    $0x2,%eax
mov    $0x70,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1440 <rsencode+0x330>
mov    -0x4(%rbp),%eax
sub    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x28(%rbp)
mov    %eax,-0x1f4(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x28(%rbp)
mov    %eax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%eax
sub    -0x1f4(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
lea    -0x1f0(%rbp),%rdi
xor    %esi,%esi
mov    $0x1c4,%edx
call   1030 <memset@plt>
movl   $0x1,-0x1f0(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jg     1250 <rsencode+0x140>
mov    -0x1fc(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x1,-0x18(%rbp)
jl     123d <rsencode+0x12d>
movslq -0x18(%rbp),%rax
mov    -0x1f0(%rbp,%rax,4),%eax
add    $0x71,%eax
mov    %eax,-0x200(%rbp)
movslq -0x14(%rbp),%rcx
lea    0x2e38(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   -0x1f0(%rbp,%rcx,4),%eax
ff
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    -0x200(%rbp),%eax
sub    %edx,%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
movslq -0x18(%rbp),%rax
mov    %edx,-0x1f0(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11cf <rsencode+0xbf>
jmp    1242 <rsencode+0x132>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b7 <rsencode+0xa7>
mov    -0x1f4(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1f8(%rbp),%eax
jge    128d <rsencode+0x17d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1259 <rsencode+0x149>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1f4(%rbp),%eax
jge    13cb <rsencode+0x2bb>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
mov    -0x1f4(%rbp),%esi
imul   -0x28(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1fc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1372 <rsencode+0x262>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1f0(%rbp,%rax,4),%eax
imul   -0x1c(%rbp),%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    $0x71,%eax
sub    %edx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
mov    -0x1f4(%rbp),%esi
add    -0x18(%rbp),%esi
add    $0x1,%esi
imul   -0x28(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x1f4(%rbp),%esi
add    -0x18(%rbp),%esi
imul   -0x28(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12e8 <rsencode+0x1d8>
movslq -0x1fc(%rbp),%rax
mov    -0x1f0(%rbp,%rax,4),%eax
imul   -0x1c(%rbp),%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    $0x71,%eax
sub    %edx,%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x1f4(%rbp),%esi
add    -0x1fc(%rbp),%esi
sub    $0x1,%esi
imul   -0x28(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1294 <rsencode+0x184>
mov    -0x1f4(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1f8(%rbp),%eax
jge    142d <rsencode+0x31d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x71,%eax
sub    %ecx,%eax
mov    $0x71,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x14(%rbp),%esi
imul   -0x28(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13d4 <rsencode+0x2c4>
jmp    1432 <rsencode+0x322>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1149 <rsencode+0x39>
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rsencode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x288,%rsp
mov    %rdx,0x18(%rsp)
lea    (%rsi,%rdi,1),%eax
test   %eax,%eax
jle    1e61 <rsencode+0xd51>
mov    %rax,%rcx
lea    (%rsi,%rdi,1),%eax
add    $0x6f,%eax
cltq
imul   $0xffffffff92492493,%rax,%rax
shr    $0x20,%rax
lea    (%rax,%rcx,1),%edx
add    $0x6f,%edx
mov    %edx,%eax
shr    $0x1f,%eax
sar    $0x6,%edx
add    %eax,%edx
lea    (%rdx,%rdi,1),%eax
add    $0xffffffff,%eax
mov    %rax,0xb0(%rsp)
lea    (%rdx,%rcx,1),%eax
add    $0xffffffff,%eax
mov    %eax,0x6c(%rsp)
movslq %edx,%rsi
cmp    $0x2,%esi
mov    $0x1,%eax
mov    %rdx,0x88(%rsp)
cmovge %edx,%eax
mov    %rax,0xa8(%rsp)
add    $0xffffffff,%ecx
mov    %rcx,0x30(%rsp)
mov    0x18(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0x78(%rsp)
mov    %rsi,%r11
shl    $0x7,%r11
mov    %rsi,%r14
shl    $0x5,%r14
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rsi,4),%rcx
mov    %rcx,0x28(%rsp)
mov    %rsi,(%rsp)
lea    (%rsi,%rsi,1),%r15
xor    %edx,%edx
mov    %rax,0x10(%rsp)
xor    %ecx,%ecx
mov    %r11,0x98(%rsp)
mov    %r14,0x80(%rsp)
mov    %r15,0xa0(%rsp)
jmp    1229 <rsencode+0x119>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%ecx
mov    %r13,%rax
add    $0x1,%rax
not    %ecx
addq   $0x1,0x78(%rsp)
addq   $0x1,0x10(%rsp)
mov    %rax,%rdx
cmp    0xa8(%rsp),%rax
je     1e61 <rsencode+0xd51>
mov    %rdx,0x90(%rsp)
mov    0xb0(%rsp),%rax
add    %ecx,%eax
cltd
mov    0x88(%rsp),%rsi
idiv   %esi
mov    %eax,%edi
add    0x6c(%rsp),%ecx
mov    %ecx,%eax
cltd
idiv   %esi
mov    %rax,0x20(%rsp)
mov    %eax,%ebx
mov    %edi,0xc(%rsp)
sub    %edi,%ebx
lea    0xc0(%rsp),%rdi
xor    %esi,%esi
mov    $0x1c4,%edx
call   1030 <memset@plt>
movl   $0x1,0xc0(%rsp)
mov    %rbx,0x60(%rsp)
test   %ebx,%ebx
jle    1550 <rsencode+0x440>
mov    0x60(%rsp),%rax
mov    %eax,%ebx
add    $0x1,%eax
mov    %rax,0x50(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,%r14d
not    %r14d
add    0x20(%rsp),%r14d
lea    (%rsp,%rbx,4),%rbp
add    $0xc0,%rbp
lea    (%rsp,%r14,4),%rcx
add    $0xc0,%rcx
lea    0x0(,%r14,4),%rdx
mov    %rbx,%rsi
sub    %r14,%rsi
lea    (%rsp,%rsi,4),%rdi
add    $0xc0,%rdi
lea    0xc4(%rsp),%rsi
lea    (%rsi,%rbx,4),%r10
mov    %rbp,%rax
sub    %rdx,%rax
cmp    %rbp,%rax
seta   %al
lea    (%rsi,%r14,4),%rdx
lea    0xc0(%rsp),%rsi
cmp    %rcx,%rsi
seta   %cl
lea    0x1(%r14),%r9
or     %al,%cl
mov    %cl,0x48(%rsp)
cmp    %rdx,%rdi
setb   %al
cmp    %r10,%rsi
setb   %r11b
and    %al,%r11b
mov    %r9,0x40(%rsp)
and    $0xfffffffffffffffc,%r9
mov    %rbx,%rax
sub    %r9,%rax
mov    %rax,0xb8(%rsp)
mov    %r9,0x38(%rsp)
neg    %r9
mov    $0xffffffff,%eax
mov    %rbx,0x58(%rsp)
lea    (%rbx,%rax,1),%r12
mov    $0x1,%r13d
jmp    135f <rsencode+0x24f>
add    $0x1,%r13
cmp    0x50(%rsp),%r13
je     1550 <rsencode+0x440>
cmp    $0x3,%r14d
setb   %al
lea    0xce3(%rip),%rcx
mov    (%rcx,%r13,4),%r8d
or     0x48(%rsp),%al
or     %r11b,%al
mov    0x58(%rsp),%rcx
jne    14ca <rsencode+0x3ba>
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %r15d,%r15d
movdqa 0xc78(%rip),%xmm6
movdqa 0xc60(%rip),%xmm7
movdqu -0x10(%r10,%r15,4),%xmm1
paddd  %xmm7,%xmm1
pshufd $0x1b,%xmm1,%xmm1
lea    (%r12,%r15,1),%eax
movdqu 0xb4(%rsp,%rax,4),%xmm2
pshufd $0x1b,%xmm2,%xmm4
pshufd $0xa,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm5
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm2
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm2,%xmm3
pmuludq %xmm6,%xmm5
pshufd $0xed,%xmm5,%xmm2
pmuludq %xmm6,%xmm4
pshufd $0xed,%xmm4,%xmm4
punpckldq %xmm2,%xmm4
pxor   %xmm2,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm6,%xmm2
psubd  %xmm2,%xmm4
movdqa %xmm4,%xmm2
psrld  $0x1f,%xmm2
psrad  $0x5,%xmm4
paddd  %xmm2,%xmm4
pshufd $0xf5,%xmm4,%xmm5
pmuludq %xmm7,%xmm4
pshufd $0xe8,%xmm4,%xmm2
pmuludq %xmm7,%xmm5
pshufd $0xe8,%xmm5,%xmm4
punpckldq %xmm4,%xmm2
psubd  %xmm3,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xf5,%xmm2,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm2,%xmm3
pshufd $0x1b,%xmm2,%xmm4
pmuludq %xmm6,%xmm2
pshufd $0xed,%xmm2,%xmm2
pmuludq %xmm6,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
pand   %xmm6,%xmm3
psubd  %xmm3,%xmm2
movdqa %xmm2,%xmm1
psrld  $0x1f,%xmm1
psrad  $0x5,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xf5,%xmm2,%xmm1
pmuludq %xmm7,%xmm1
pmuludq %xmm7,%xmm2
pshufd $0xe2,%xmm2,%xmm2
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
psubd  %xmm1,%xmm4
movdqu %xmm4,-0x10(%r10,%r15,4)
add    $0xfffffffffffffffc,%r15
cmp    %r15,%r9
jne    13a0 <rsencode+0x290>
mov    0xb8(%rsp),%rcx
mov    0x38(%rsp),%rax
cmp    %rax,0x40(%rsp)
je     1350 <rsencode+0x240>
lea    0x1(%rcx),%r15d
lea    (%rsp,%rcx,4),%rbx
add    $0xc0,%rbx
add    $0xffffffff,%ecx
lea    (%rsp,%rcx,4),%rcx
add    $0xc0,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rbx,%rdx,4),%ebp
mov    (%rcx,%rdx,4),%edi
imul   %r8d,%edi
movslq %edi,%rdi
imul   $0x487ede05,%rdi,%rsi
mov    %rsi,%rax
shr    $0x3f,%rax
sar    $0x25,%rsi
add    %eax,%esi
imul   $0x71,%esi,%eax
sub    %edi,%eax
add    %ebp,%eax
add    $0x71,%eax
cltq
imul   $0x487ede05,%rax,%rsi
mov    %rsi,%rdi
shr    $0x3f,%rdi
sar    $0x25,%rsi
add    %edi,%esi
imul   $0x71,%esi,%esi
sub    %esi,%eax
mov    %eax,(%rbx,%rdx,4)
add    $0xffffffffffffffff,%rdx
lea    (%rdx,%r15,1),%eax
cmp    $0x1,%eax
jg     14f0 <rsencode+0x3e0>
jmp    1350 <rsencode+0x240>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%r12
mov    0xc(%rsp),%r10d
cmp    %r10d,%r12d
mov    0x28(%rsp),%rbx
pxor   %xmm5,%xmm5
movdqa 0xaa2(%rip),%xmm6
movdqa 0xa8a(%rip),%xmm7
movdqa 0xaa1(%rip),%xmm8
movdqa 0xaa8(%rip),%xmm9
mov    0x90(%rsp),%r13
movdqa 0xaa7(%rip),%xmm10
jle    17c0 <rsencode+0x6b0>
movslq %r10d,%r8
movslq %r12d,%rax
mov    %rax,%r9
sub    %r8,%r9
cmp    $0x8,%r9
jb     15d0 <rsencode+0x4c0>
cmpl   $0x6f,0x30(%rsp)
ja     15d0 <rsencode+0x4c0>
cmp    $0x20,%r9
jae    15d8 <rsencode+0x4c8>
xor    %edx,%edx
jmp    16d0 <rsencode+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8,%rdi
jmp    1720 <rsencode+0x610>
mov    %r9,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rcx
jae    1600 <rsencode+0x4f0>
xor    %ebp,%ebp
jmp    167f <rsencode+0x56f>
and    $0xfffffffffffffffc,%rdi
lea    0x40(%r8),%r10
mov    (%rsp),%rsi
imul   %rsi,%r10
mov    %rsi,%r11
imul   %r8,%r11
lea    0x20(%r8),%r14
imul   %rsi,%r14
lea    0x60(%r8),%rcx
imul   %rsi,%rcx
mov    0x78(%rsp),%rsi
xor    %ebp,%ebp
mov    0x98(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
movdqu %xmm5,-0x10(%rsi,%r11,1)
movdqu %xmm5,(%rsi,%r11,1)
movdqu %xmm5,-0x10(%rsi,%r14,1)
movdqu %xmm5,(%rsi,%r14,1)
movdqu %xmm5,-0x10(%rsi,%r10,1)
movdqu %xmm5,(%rsi,%r10,1)
movdqu %xmm5,-0x10(%rsi,%rcx,1)
movdqu %xmm5,(%rsi,%rcx,1)
sub    $0xffffffffffffff80,%rbp
add    %r15,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1640 <rsencode+0x530>
test   %rbx,%rbx
mov    0x80(%rsp),%rcx
je     16b7 <rsencode+0x5a7>
add    %r8,%rbp
imul   (%rsp),%rbp
add    0x18(%rsp),%rbp
nopl   0x0(%rax)
movdqu %xmm5,0x0(%rbp,%r13,1)
movdqu %xmm5,0x10(%rbp,%r13,1)
add    %rcx,%rbp
add    $0xffffffffffffffff,%rbx
jne    16a0 <rsencode+0x590>
cmp    %rdx,%r9
mov    0x28(%rsp),%rbx
mov    0xc(%rsp),%r10d
je     17c0 <rsencode+0x6b0>
test   $0x18,%r9b
je     171a <rsencode+0x60a>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rcx,%r8,1),%rdi
mov    %rdx,%rsi
sub    %rcx,%rsi
add    %r8,%rdx
imul   (%rsp),%rdx
add    0x10(%rsp),%rdx
mov    0x70(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,(%rdx)
add    %rbp,%rdx
add    $0x8,%rsi
jne    1700 <rsencode+0x5f0>
cmp    %rcx,%r9
jne    1720 <rsencode+0x610>
jmp    17c0 <rsencode+0x6b0>
add    %r8,%rdx
mov    %rdx,%rdi
mov    %r12d,%edx
sub    %edi,%edx
mov    %rdi,%rcx
not    %rcx
add    %rax,%rcx
and    $0x3,%rdx
je     1767 <rsencode+0x657>
mov    (%rsp),%rbx
mov    %rbx,%rsi
imul   %rdi,%rsi
add    0x10(%rsp),%rsi
neg    %rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movb   $0x0,(%rsi)
add    $0xffffffffffffffff,%rbp
add    %rbx,%rsi
cmp    %rbp,%rdx
jne    1750 <rsencode+0x640>
sub    %rbp,%rdi
mov    0x28(%rsp),%rbx
cmp    $0x3,%rcx
jb     17c0 <rsencode+0x6b0>
sub    %rdi,%rax
lea    0x3(%rdi),%rcx
mov    (%rsp),%rbp
imul   %rbp,%rcx
lea    0x2(%rdi),%rdx
imul   %rbp,%rdx
mov    %rbp,%rsi
imul   %rdi,%rsi
add    $0x1,%rdi
imul   %rbp,%rdi
mov    0x10(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movb   $0x0,0x0(%rbp,%rsi,1)
movb   $0x0,0x0(%rbp,%rdi,1)
movb   $0x0,0x0(%rbp,%rdx,1)
movb   $0x0,0x0(%rbp,%rcx,1)
add    %rbx,%rbp
add    $0xfffffffffffffffc,%rax
jne    17a0 <rsencode+0x690>
nopl   (%rax)
test   %r10d,%r10d
mov    0x18(%rsp),%r9
mov    (%rsp),%rbp
jle    1aa0 <rsencode+0x990>
cmpl   $0x70,0x30(%rsp)
setb   %al
mov    0xc(%rsp),%edi
mov    %edi,%ecx
mov    0x88(%rsp),%rsi
imul   %esi,%ecx
movslq %ecx,%rcx
add    %r13,%rcx
mov    %rcx,0x58(%rsp)
mov    0x60(%rsp),%rcx
lea    -0x1(%rcx),%r10d
movslq %ecx,%rdx
mov    0xc0(%rsp,%rdx,4),%ecx
mov    %ecx,0x50(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x1(%rcx),%edx
imul   %esi,%edx
movslq %edx,%rcx
add    %r13,%rcx
mov    %rcx,0x48(%rsp)
mov    %edi,%r15d
cmp    $0x2,%r10d
mov    $0x1,%ecx
cmovl  %ecx,%r10d
cmp    $0x4,%r10d
setae  %cl
and    %al,%cl
mov    %cl,0x40(%rsp)
mov    %r10d,%r11d
and    $0x7ffffffc,%r11d
mov    %rbp,%r14
imul   %r15,%r14
lea    0x1(%r15),%rax
mov    %rbp,%r12
mov    %rax,0x38(%rsp)
imul   %rax,%r12
xor    %r8d,%r8d
jmp    18c5 <rsencode+0x7b5>
cs nopw 0x0(%rax,%rax,1)
imul   0x50(%rsp),%r13d
movslq %r13d,%rax
imul   $0x487ede05,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x25,%rcx
add    %edx,%ecx
imul   $0x71,%ecx,%ecx
sub    %ecx,%eax
mov    $0x71,%cl
sub    %al,%cl
movzbl %cl,%eax
imul   $0x91,%eax,%ecx
shr    $0xe,%ecx
imul   $0x71,%ecx,%ecx
sub    %cl,%al
mov    0x48(%rsp),%rcx
mov    %al,(%r9,%rcx,1)
add    $0x1,%r8
cmp    %r15,%r8
mov    0x90(%rsp),%r13
je     1aa0 <rsencode+0x990>
mov    %r8,%rax
imul   %rbp,%rax
add    %r13,%rax
movzbl (%r9,%rax,1),%eax
mov    0x58(%rsp),%rcx
movzbl (%r9,%rcx,1),%edx
add    %eax,%edx
imul   $0x487f,%edx,%eax
shr    $0x15,%eax
imul   $0x71,%eax,%eax
sub    %eax,%edx
movzwl %dx,%r13d
cmpl   $0x2,0x60(%rsp)
jl     1870 <rsencode+0x760>
cmpb   $0x0,0x40(%rsp)
je     1a20 <rsencode+0x910>
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    0x10(%rsp),%rdi
xor    %r9d,%r9d
mov    0x28(%rsp),%rax
nop
movdqu 0xc4(%rsp,%r9,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
movdqa %xmm1,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm1
pshufd $0xf5,%xmm0,%xmm4
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm4
punpckldq %xmm4,%xmm1
pmuludq %xmm6,%xmm3
pshufd $0xed,%xmm3,%xmm3
pmuludq %xmm6,%xmm2
pshufd $0xed,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
pxor   %xmm2,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm6,%xmm2
psubd  %xmm2,%xmm3
movdqa %xmm3,%xmm2
psrld  $0x1f,%xmm2
psrad  $0x5,%xmm3
paddd  %xmm2,%xmm3
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm7,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
movd   (%rdi,%r12,1),%xmm2
punpcklbw %xmm5,%xmm2
punpcklwd %xmm5,%xmm2
psubd  %xmm1,%xmm3
paddd  %xmm7,%xmm2
paddd  %xmm3,%xmm2
pshuflw $0xe8,%xmm2,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
movdqa %xmm1,%xmm2
pmulhuw %xmm8,%xmm2
psrlw  $0x5,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm1
pand   %xmm10,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm1,(%rdi,%r14,1)
add    $0x4,%r9
add    %rax,%rdi
cmp    %r9,%r11
jne    1920 <rsencode+0x810>
mov    %r11,%rdi
cmp    %r10,%r11
mov    0x18(%rsp),%r9
je     1870 <rsencode+0x760>
jmp    1a22 <rsencode+0x912>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edi,%edi
lea    (%r15,%rdi,1),%rbx
imul   %rbp,%rbx
mov    0x38(%rsp),%rax
lea    (%rax,%rdi,1),%rdx
imul   %rbp,%rdx
mov    0x10(%rsp),%rax
nopl   0x0(%rax)
mov    0xc4(%rsp,%rdi,4),%ebp
imul   %r13d,%ebp
add    $0x1,%rdi
movslq %ebp,%rbp
imul   $0x487ede05,%rbp,%rcx
mov    %rcx,%rsi
shr    $0x3f,%rsi
sar    $0x25,%rcx
add    %esi,%ecx
imul   $0x71,%ecx,%ecx
movzbl (%rax,%rdx,1),%esi
sub    %ebp,%ecx
mov    (%rsp),%rbp
add    %esi,%ecx
add    $0x71,%ecx
movzwl %cx,%esi
imul   $0x487f,%esi,%esi
shr    $0x15,%esi
imul   $0x71,%esi,%esi
sub    %esi,%ecx
mov    %cl,(%rax,%rbx,1)
add    %rbp,%rax
cmp    %rdi,%r10
jne    1a40 <rsencode+0x930>
jmp    1870 <rsencode+0x760>
nopl   0x0(%rax)
mov    0x20(%rsp),%r12
mov    0xc(%rsp),%eax
cmp    %eax,%r12d
mov    0x80(%rsp),%r14
mov    0xa0(%rsp),%r15
jle    1200 <rsencode+0xf0>
movslq %eax,%r9
movslq %r12d,%rax
mov    %rax,%r10
sub    %r9,%r10
cmp    $0x8,%r10
jb     1b80 <rsencode+0xa70>
cmpl   $0x6f,0x30(%rsp)
ja     1b80 <rsencode+0xa70>
cmp    $0x10,%r10
jae    1c46 <rsencode+0xb36>
xor    %edx,%edx
mov    (%rsp),%rbp
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rsi,%r9,1),%rcx
mov    %rdx,%rdi
sub    %rsi,%rdi
add    %r9,%rdx
imul   %rbp,%rdx
add    0x10(%rsp),%rdx
mov    0x70(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%rdx),%xmm0
punpcklbw %xmm5,%xmm0
movdqa %xmm9,%xmm1
psubw  %xmm0,%xmm1
movdqa %xmm1,%xmm0
pmulhw %xmm8,%xmm0
movdqa %xmm0,%xmm2
psrlw  $0xf,%xmm2
psrlw  $0x5,%xmm0
paddw  %xmm2,%xmm0
pmullw %xmm9,%xmm0
psubw  %xmm0,%xmm1
pand   %xmm10,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdx)
add    %rbp,%rdx
add    $0x8,%rdi
jne    1b20 <rsencode+0xa10>
cmp    %rsi,%r10
je     1200 <rsencode+0xf0>
jmp    1b83 <rsencode+0xa73>
cs nopw 0x0(%rax,%rax,1)
mov    %r9,%rcx
sub    %ecx,%r12d
mov    %rcx,%rdx
test   $0x1,%r12b
je     1bc7 <rsencode+0xab7>
mov    %rcx,%rdx
imul   (%rsp),%rdx
add    %r13,%rdx
mov    0x18(%rsp),%rbx
movzbl (%rbx,%rdx,1),%esi
mov    $0x71,%edi
sub    %esi,%edi
imul   $0x487f,%edi,%esi
mov    %esi,%ebp
shr    $0x1f,%ebp
shr    $0x15,%esi
add    %ebp,%esi
imul   $0x71,%esi,%esi
sub    %esi,%edi
mov    %dil,(%rbx,%rdx,1)
lea    0x1(%rcx),%rdx
not    %rcx
add    %rax,%rcx
je     1200 <rsencode+0xf0>
sub    %rdx,%rax
mov    (%rsp),%rsi
mov    %rsi,%rcx
imul   %rdx,%rcx
add    $0x1,%rdx
imul   %rsi,%rdx
mov    0x10(%rsp),%rsi
xchg   %ax,%ax
movzbl (%rsi,%rcx,1),%edi
mov    $0x71,%ebp
sub    %edi,%ebp
imul   $0x487f,%ebp,%edi
mov    %edi,%ebx
shr    $0x1f,%ebx
shr    $0x15,%edi
add    %ebx,%edi
imul   $0x71,%edi,%edi
sub    %edi,%ebp
mov    %bpl,(%rsi,%rcx,1)
movzbl (%rsi,%rdx,1),%edi
mov    $0x71,%ebp
sub    %edi,%ebp
imul   $0x487f,%ebp,%edi
mov    %edi,%ebx
shr    $0x1f,%ebx
shr    $0x15,%edi
add    %ebx,%edi
imul   $0x71,%edi,%edi
sub    %edi,%ebp
mov    %bpl,(%rsi,%rdx,1)
add    %r15,%rsi
add    $0xfffffffffffffffe,%rax
jne    1bf0 <rsencode+0xae0>
jmp    1200 <rsencode+0xf0>
mov    %r10,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rcx
mov    %rcx,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1e53 <rsencode+0xd43>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x10(%r9),%rbx
mov    (%rsp),%rsi
imul   %rsi,%rbx
imul   %r9,%rsi
mov    0x10(%rsp),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rcx,%rsi,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm5,%xmm2
punpckhbw %xmm5,%xmm1
movdqa %xmm9,%xmm0
psubw  %xmm1,%xmm0
movdqa %xmm9,%xmm1
psubw  %xmm2,%xmm1
movdqa %xmm1,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm1
movdqa %xmm0,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm0
pand   %xmm10,%xmm0
pand   %xmm10,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,(%rcx,%rsi,1)
movdqu (%rcx,%rbx,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm5,%xmm2
punpckhbw %xmm5,%xmm1
movdqa %xmm9,%xmm0
psubw  %xmm1,%xmm0
movdqa %xmm9,%xmm1
psubw  %xmm2,%xmm1
movdqa %xmm1,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm1
movdqa %xmm0,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm0
pand   %xmm10,%xmm0
pand   %xmm10,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,(%rcx,%rbx,1)
add    $0x20,%rdi
add    %r14,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1c90 <rsencode+0xb80>
test   $0x1,%r8b
je     1e35 <rsencode+0xd25>
add    %r9,%rdi
imul   (%rsp),%rdi
add    %r13,%rdi
mov    0x18(%rsp),%rcx
movdqu (%rcx,%rdi,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm5,%xmm2
punpckhbw %xmm5,%xmm1
movdqa %xmm9,%xmm0
psubw  %xmm1,%xmm0
movdqa %xmm9,%xmm1
psubw  %xmm2,%xmm1
movdqa %xmm1,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm1
movdqa %xmm0,%xmm2
pmulhw %xmm8,%xmm2
movdqa %xmm2,%xmm3
psrlw  $0xf,%xmm3
psrlw  $0x5,%xmm2
paddw  %xmm3,%xmm2
pmullw %xmm9,%xmm2
psubw  %xmm2,%xmm0
pand   %xmm10,%xmm0
pand   %xmm10,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,(%rcx,%rdi,1)
cmp    %rdx,%r10
je     1200 <rsencode+0xf0>
test   $0x8,%r10b
jne    1aef <rsencode+0x9df>
add    %r9,%rdx
mov    %rdx,%rcx
jmp    1b83 <rsencode+0xa73>
xor    %edi,%edi
test   $0x1,%r8b
jne    1da7 <rsencode+0xc97>
jmp    1e35 <rsencode+0xd25>
add    $0x288,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@rsencode.root = internal global [112 x i32] [i32 1, i32 3, i32 9, i32 27, i32 81, i32 17, i32 51, i32 40, i32 7, i32 21, i32 63, i32 76, i32 2, i32 6, i32 18, i32 54, i32 49, i32 34, i32 102, i32 80, i32 14, i32 42, i32 13, i32 39, i32 4, i32 12, i32 36, i32 108, i32 98, i32 68, i32 91, i32 47, i32 28, i32 84, i32 26, i32 78, i32 8, i32 24, i32 72, i32 103, i32 83, i32 23, i32 69, i32 94, i32 56, i32 55, i32 52, i32 43, i32 16, i32 48, i32 31, i32 93, i32 53, i32 46, i32 25, i32 75, i32 112, i32 110, i32 104, i32 86, i32 32, i32 96, i32 62, i32 73, i32 106, i32 92, i32 50, i32 37, i32 111, i32 107, i32 95, i32 59, i32 64, i32 79, i32 11, i32 33, i32 99, i32 71, i32 100, i32 74, i32 109, i32 101, i32 77, i32 5, i32 15, i32 45, i32 22, i32 66, i32 85, i32 29, i32 87, i32 35, i32 105, i32 89, i32 41, i32 10, i32 30, i32 90, i32 44, i32 19, i32 57, i32 58, i32 61, i32 70, i32 97, i32 65, i32 82, i32 20, i32 60, i32 67, i32 88, i32 38]
define void @rsencode(i32 %0, i32 %1, i8* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [113 x i32]
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i8* %2, i8** %6
%17 = load i32, i32* %4
%18 = load i32, i32* %5
%19 = add nsw i32 %17, %18
store i32 %19, i32* %10
%20 = load i32, i32* %10
%21 = add nsw i32 %20, 113
%22 = sub nsw i32 %21, 2
%23 = sdiv i32 %22, 112
store i32 %23, i32* %12
store i32 0, i32* %11
br label %24
24: ; preds = %236, %3
%25 = load i32, i32* %11
%26 = load i32, i32* %12
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %239
28: ; preds = %24
%29 = load i32, i32* %4
%30 = load i32, i32* %11
%31 = sub nsw i32 %29, %30
%32 = load i32, i32* %12
%33 = add nsw i32 %31, %32
%34 = sub nsw i32 %33, 1
%35 = load i32, i32* %12
%36 = sdiv i32 %34, %35
store i32 %36, i32* %14
%37 = load i32, i32* %10
%38 = load i32, i32* %11
%39 = sub nsw i32 %37, %38
%40 = load i32, i32* %12
%41 = add nsw i32 %39, %40
%42 = sub nsw i32 %41, 1
%43 = load i32, i32* %12
%44 = sdiv i32 %42, %43
store i32 %44, i32* %15
%45 = load i32, i32* %15
%46 = load i32, i32* %14
%47 = sub nsw i32 %45, %46
store i32 %47, i32* %16
%48 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 0
%49 = call i32 @memset(i32* %48, i32 0, i32 452)
%50 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 0
store i32 1, i32* %50
store i32 1, i32* %7
br label %51
51: ; preds = %86, %28
%52 = load i32, i32* %7
%53 = load i32, i32* %16
%54 = icmp sle i32 %52, %53
br i1 %54, label %55, label %89
55: ; preds = %51
%56 = load i32, i32* %16
store i32 %56, i32* %8
br label %57
57: ; preds = %82, %55
%58 = load i32, i32* %8
%59 = icmp sge i32 %58, 1
br i1 %59, label %60, label %85
60: ; preds = %57
%61 = load i32, i32* %8
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 %62
%64 = load i32, i32* %63
%65 = add nsw i32 113, %64
%66 = load i32, i32* %7
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [112 x i32], [112 x i32]* @rsencode.root, i64 0, i64 %67
%69 = load i32, i32* %68
%70 = load i32, i32* %8
%71 = sub nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 %72
%74 = load i32, i32* %73
%75 = mul nsw i32 %69, %74
%76 = srem i32 %75, 113
%77 = sub nsw i32 %65, %76
%78 = srem i32 %77, 113
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 %80
store i32 %78, i32* %81
br label %82
82: ; preds = %60
%83 = load i32, i32* %8
%84 = add nsw i32 %83, -1
store i32 %84, i32* %8
br label %57
85: ; preds = %57
br label %86
86: ; preds = %85
%87 = load i32, i32* %7
%88 = add nsw i32 %87, 1
store i32 %88, i32* %7
br label %51
89: ; preds = %51
%90 = load i32, i32* %14
store i32 %90, i32* %7
br label %91
91: ; preds = %104, %89
%92 = load i32, i32* %7
%93 = load i32, i32* %15
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %107
95: ; preds = %91
%96 = load i8*, i8** %6
%97 = load i32, i32* %11
%98 = load i32, i32* %7
%99 = load i32, i32* %12
%100 = mul nsw i32 %98, %99
%101 = add nsw i32 %97, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %96, i64 %102
store i8 0, i8* %103
br label %104
104: ; preds = %95
%105 = load i32, i32* %7
%106 = add nsw i32 %105, 1
store i32 %106, i32* %7
br label %91
107: ; preds = %91
store i32 0, i32* %7
br label %108
108: ; preds = %201, %107
%109 = load i32, i32* %7
%110 = load i32, i32* %14
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %204
112: ; preds = %108
%113 = load i8*, i8** %6
%114 = load i32, i32* %11
%115 = load i32, i32* %7
%116 = load i32, i32* %12
%117 = mul nsw i32 %115, %116
%118 = add nsw i32 %114, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %113, i64 %119
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = load i8*, i8** %6
%124 = load i32, i32* %11
%125 = load i32, i32* %14
%126 = load i32, i32* %12
%127 = mul nsw i32 %125, %126
%128 = add nsw i32 %124, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %123, i64 %129
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = add nsw i32 %122, %132
%134 = srem i32 %133, 113
store i32 %134, i32* %9
store i32 0, i32* %8
br label %135
135: ; preds = %176, %112
%136 = load i32, i32* %8
%137 = load i32, i32* %16
%138 = sub nsw i32 %137, 1
%139 = icmp slt i32 %136, %138
br i1 %139, label %140, label %179
140: ; preds = %135
%141 = load i32, i32* %8
%142 = add nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 %143
%145 = load i32, i32* %144
%146 = load i32, i32* %9
%147 = mul nsw i32 %145, %146
%148 = srem i32 %147, 113
%149 = sub nsw i32 113, %148
%150 = load i8*, i8** %6
%151 = load i32, i32* %11
%152 = load i32, i32* %14
%153 = load i32, i32* %8
%154 = add nsw i32 %152, %153
%155 = add nsw i32 %154, 1
%156 = load i32, i32* %12
%157 = mul nsw i32 %155, %156
%158 = add nsw i32 %151, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i8, i8* %150, i64 %159
%161 = load i8, i8* %160
%162 = zext i8 %161 to i32
%163 = add nsw i32 %149, %162
%164 = srem i32 %163, 113
%165 = trunc i32 %164 to i8
%166 = load i8*, i8** %6
%167 = load i32, i32* %11
%168 = load i32, i32* %14
%169 = load i32, i32* %8
%170 = add nsw i32 %168, %169
%171 = load i32, i32* %12
%172 = mul nsw i32 %170, %171
%173 = add nsw i32 %167, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %166, i64 %174
store i8 %165, i8* %175
br label %176
176: ; preds = %140
%177 = load i32, i32* %8
%178 = add nsw i32 %177, 1
store i32 %178, i32* %8
br label %135
179: ; preds = %135
%180 = load i32, i32* %16
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [113 x i32], [113 x i32]* %13, i64 0, i64 %181
%183 = load i32, i32* %182
%184 = load i32, i32* %9
%185 = mul nsw i32 %183, %184
%186 = srem i32 %185, 113
%187 = sub nsw i32 113, %186
%188 = srem i32 %187, 113
%189 = trunc i32 %188 to i8
%190 = load i8*, i8** %6
%191 = load i32, i32* %11
%192 = load i32, i32* %14
%193 = load i32, i32* %16
%194 = add nsw i32 %192, %193
%195 = sub nsw i32 %194, 1
%196 = load i32, i32* %12
%197 = mul nsw i32 %195, %196
%198 = add nsw i32 %191, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %190, i64 %199
store i8 %189, i8* %200
br label %201
201: ; preds = %179
%202 = load i32, i32* %7
%203 = add nsw i32 %202, 1
store i32 %203, i32* %7
br label %108
204: ; preds = %108
%205 = load i32, i32* %14
store i32 %205, i32* %7
br label %206
206: ; preds = %232, %204
%207 = load i32, i32* %7
%208 = load i32, i32* %15
%209 = icmp slt i32 %207, %208
br i1 %209, label %210, label %235
210: ; preds = %206
%211 = load i8*, i8** %6
%212 = load i32, i32* %11
%213 = load i32, i32* %7
%214 = load i32, i32* %12
%215 = mul nsw i32 %213, %214
%216 = add nsw i32 %212, %215
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %211, i64 %217
%219 = load i8, i8* %218
%220 = zext i8 %219 to i32
%221 = sub nsw i32 113, %220
%222 = srem i32 %221, 113
%223 = trunc i32 %222 to i8
%224 = load i8*, i8** %6
%225 = load i32, i32* %11
%226 = load i32, i32* %7
%227 = load i32, i32* %12
%228 = mul nsw i32 %226, %227
%229 = add nsw i32 %225, %228
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i8, i8* %224, i64 %230
store i8 %223, i8* %231
br label %232
232: ; preds = %210
%233 = load i32, i32* %7
%234 = add nsw i32 %233, 1
store i32 %234, i32* %7
br label %206
235: ; preds = %206
br label %236
236: ; preds = %235
%237 = load i32, i32* %11
%238 = add nsw i32 %237, 1
store i32 %238, i32* %11
br label %24
239: ; preds = %24
ret void
}

LLVM IR (-O2):
@rsencode.root = internal unnamed_addr constant [112 x i32] [i32 1, i32 3, i32 9, i32 27, i32 81, i32 17, i32 51, i32 40, i32 7, i32 21, i32 63, i32 76, i32 2, i32 6, i32 18, i32 54, i32 49, i32 34, i32 102, i32 80, i32 14, i32 42, i32 13, i32 39, i32 4, i32 12, i32 36, i32 108, i32 98, i32 68, i32 91, i32 47, i32 28, i32 84, i32 26, i32 78, i32 8, i32 24, i32 72, i32 103, i32 83, i32 23, i32 69, i32 94, i32 56, i32 55, i32 52, i32 43, i32 16, i32 48, i32 31, i32 93, i32 53, i32 46, i32 25, i32 75, i32 112, i32 110, i32 104, i32 86, i32 32, i32 96, i32 62, i32 73, i32 106, i32 92, i32 50, i32 37, i32 111, i32 107, i32 95, i32 59, i32 64, i32 79, i32 11, i32 33, i32 99, i32 71, i32 100, i32 74, i32 109, i32 101, i32 77, i32 5, i32 15, i32 45, i32 22, i32 66, i32 85, i32 29, i32 87, i32 35, i32 105, i32 89, i32 41, i32 10, i32 30, i32 90, i32 44, i32 19, i32 57, i32 58, i32 61, i32 70, i32 97, i32 65, i32 82, i32 20, i32 60, i32 67, i32 88, i32 38]
define void @rsencode(i32 %0, i32 %1, i8* nocapture %2) {
%4 = alloca [113 x i32]
%5 = bitcast [113 x i32]* %4 to i8*
%6 = add nsw i32 %1, %0
%7 = add nsw i32 %6, 111
%8 = sdiv i32 %7, 112
%9 = icmp sgt i32 %6, 0
br i1 %9, label %10, label %502
10: ; preds = %3
%11 = add nsw i32 %8, -1
%12 = add i32 %11, %0
%13 = add i32 %11, %6
%14 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 0
%15 = sext i32 %8 to i64
%16 = call i32 @llvm.smax.i32(i32 %8, i32 1)
%17 = zext i32 %16 to i64
%18 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 1
%19 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 1
%20 = add i32 %6, -1
%21 = icmp ult i32 %20, 112
%22 = add i32 %6, -1
%23 = icmp ult i32 %22, 112
%24 = add i32 %6, -1
%25 = icmp ult i32 %24, 112
br label %26
26: ; preds = %10, %498
%27 = phi i64 [ 0, %10 ], [ %499, %498 ]
%28 = phi i32 [ 0, %10 ], [ %500, %498 ]
%29 = trunc i64 %27 to i32
%30 = add i32 %12, %28
%31 = sdiv i32 %30, %8
%32 = add i32 %13, %28
%33 = sdiv i32 %32, %8
%34 = sub i32 %33, %31
%35 = call i32 @memset(i32* %14, i32 0, i32 452)
store i32 1, i32* %14
%36 = icmp slt i32 %34, 1
br i1 %36, label %75, label %37
37: ; preds = %26
%38 = zext i32 %34 to i64
%39 = add i32 %33, 1
%40 = sub i32 %39, %31
%41 = zext i32 %40 to i64
%42 = xor i32 %31, -1
%43 = add i32 %33, %42
%44 = getelementptr [113 x i32], [113 x i32]* %4, i64 0, i64 %38
%45 = zext i32 %43 to i64
%46 = getelementptr [113 x i32], [113 x i32]* %4, i64 0, i64 %45
%47 = xor i32 %31, -1
%48 = add i32 %33, %47
%49 = zext i32 %48 to i64
%50 = sub nsw i64 %38, %49
%51 = getelementptr [113 x i32], [113 x i32]* %4, i64 0, i64 %50
%52 = getelementptr i32, i32* %18, i64 %38
%53 = getelementptr i32, i32* %19, i64 %49
%54 = xor i32 %31, -1
%55 = add i32 %33, %54
%56 = zext i32 %55 to i64
%57 = add nuw nsw i64 %56, 1
%58 = icmp ult i32 %55, 3
%59 = zext i32 %43 to i64
%60 = sub nsw i64 0, %59
%61 = getelementptr i32, i32* %44, i64 %60
%62 = icmp ugt i32* %61, %44
%63 = zext i32 %43 to i64
%64 = sub nsw i64 0, %63
%65 = getelementptr i32, i32* %46, i64 %64
%66 = icmp ugt i32* %65, %46
%67 = or i1 %62, %66
%68 = icmp ult i32* %51, %53
%69 = bitcast i32* %52 to [113 x i32]*
%70 = icmp ult [113 x i32]* %4, %69
%71 = and i1 %68, %70
%72 = and i64 %57, 8589934588
%73 = sub nsw i64 %38, %72
%74 = icmp eq i64 %57, %72
br label %190
75: ; preds = %241, %26
%76 = icmp sgt i32 %33, %31
br i1 %76, label %77, label %244
77: ; preds = %75
%78 = sext i32 %31 to i64
%79 = sext i32 %33 to i64
%80 = sub nsw i64 %79, %78
%81 = icmp ugt i64 %80, 7
%82 = select i1 %81, i1 %21, i1 false
br i1 %82, label %83, label %171
83: ; preds = %77
%84 = icmp ult i64 %80, 32
br i1 %84, label %153, label %85
85: ; preds = %83
%86 = and i64 %80, -32
%87 = add nsw i64 %86, -32
%88 = lshr exact i64 %87, 5
%89 = add nuw nsw i64 %88, 1
%90 = and i64 %89, 3
%91 = icmp ult i64 %87, 96
br i1 %91, label %131, label %92
92: ; preds = %85
%93 = and i64 %89, 1152921504606846972
br label %94
94: ; preds = %94, %92
%95 = phi i64 [ 0, %92 ], [ %128, %94 ]
%96 = phi i64 [ 0, %92 ], [ %129, %94 ]
%97 = add i64 %95, %78
%98 = mul nsw i64 %97, %15
%99 = add nsw i64 %98, %27
%100 = getelementptr inbounds i8, i8* %2, i64 %99
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %101
%102 = getelementptr inbounds i8, i8* %100, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %103
%104 = or i64 %95, 32
%105 = add i64 %104, %78
%106 = mul nsw i64 %105, %15
%107 = add nsw i64 %106, %27
%108 = getelementptr inbounds i8, i8* %2, i64 %107
%109 = bitcast i8* %108 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %109
%110 = getelementptr inbounds i8, i8* %108, i64 16
%111 = bitcast i8* %110 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %111
%112 = or i64 %95, 64
%113 = add i64 %112, %78
%114 = mul nsw i64 %113, %15
%115 = add nsw i64 %114, %27
%116 = getelementptr inbounds i8, i8* %2, i64 %115
%117 = bitcast i8* %116 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %117
%118 = getelementptr inbounds i8, i8* %116, i64 16
%119 = bitcast i8* %118 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %119
%120 = or i64 %95, 96
%121 = add i64 %120, %78
%122 = mul nsw i64 %121, %15
%123 = add nsw i64 %122, %27
%124 = getelementptr inbounds i8, i8* %2, i64 %123
%125 = bitcast i8* %124 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %125
%126 = getelementptr inbounds i8, i8* %124, i64 16
%127 = bitcast i8* %126 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %127
%128 = add nuw i64 %95, 128
%129 = add i64 %96, 4
%130 = icmp eq i64 %129, %93
br i1 %130, label %131, label %94
131: ; preds = %94, %85
%132 = phi i64 [ 0, %85 ], [ %128, %94 ]
%133 = icmp eq i64 %90, 0
br i1 %133, label %147, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %144, %134 ], [ %132, %131 ]
%136 = phi i64 [ %145, %134 ], [ 0, %131 ]
%137 = add i64 %135, %78
%138 = mul nsw i64 %137, %15
%139 = add nsw i64 %138, %27
%140 = getelementptr inbounds i8, i8* %2, i64 %139
%141 = bitcast i8* %140 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %141
%142 = getelementptr inbounds i8, i8* %140, i64 16
%143 = bitcast i8* %142 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %143
%144 = add nuw i64 %135, 32
%145 = add i64 %136, 1
%146 = icmp eq i64 %145, %90
br i1 %146, label %147, label %134
147: ; preds = %134, %131
%148 = icmp eq i64 %80, %86
br i1 %148, label %244, label %149
149: ; preds = %147
%150 = add nsw i64 %86, %78
%151 = and i64 %80, 24
%152 = icmp eq i64 %151, 0
br i1 %152, label %171, label %153
153: ; preds = %83, %149
%154 = phi i64 [ %86, %149 ], [ 0, %83 ]
%155 = sext i32 %33 to i64
%156 = sext i32 %31 to i64
%157 = sub nsw i64 %155, %156
%158 = and i64 %157, -8
%159 = add nsw i64 %158, %78
br label %160
160: ; preds = %160, %153
%161 = phi i64 [ %154, %153 ], [ %167, %160 ]
%162 = add i64 %161, %78
%163 = mul nsw i64 %162, %15
%164 = add nsw i64 %163, %27
%165 = getelementptr inbounds i8, i8* %2, i64 %164
%166 = bitcast i8* %165 to <8 x i8>*
store <8 x i8> zeroinitializer, <8 x i8>* %166
%167 = add nuw i64 %161, 8
%168 = icmp eq i64 %167, %158
br i1 %168, label %169, label %160
169: ; preds = %160
%170 = icmp eq i64 %157, %158
br i1 %170, label %244, label %171
171: ; preds = %77, %149, %169
%172 = phi i64 [ %78, %77 ], [ %150, %149 ], [ %159, %169 ]
%173 = sub nsw i64 %79, %172
%174 = xor i64 %172, -1
%175 = add nsw i64 %174, %79
%176 = and i64 %173, 3
%177 = icmp eq i64 %176, 0
br i1 %177, label %187, label %178
178: ; preds = %171, %178
%179 = phi i64 [ %184, %178 ], [ %172, %171 ]
%180 = phi i64 [ %185, %178 ], [ 0, %171 ]
%181 = mul nsw i64 %179, %15
%182 = add nsw i64 %181, %27
%183 = getelementptr inbounds i8, i8* %2, i64 %182
store i8 0, i8* %183
%184 = add nsw i64 %179, 1
%185 = add i64 %180, 1
%186 = icmp eq i64 %185, %176
br i1 %186, label %187, label %178
187: ; preds = %178, %171
%188 = phi i64 [ %172, %171 ], [ %184, %178 ]
%189 = icmp ult i64 %175, 3
br i1 %189, label %244, label %269
190: ; preds = %241, %37
%191 = phi i64 [ 1, %37 ], [ %242, %241 ]
%192 = getelementptr inbounds [112 x i32], [112 x i32]* @rsencode.root, i64 0, i64 %191
%193 = load i32, i32* %192
%194 = select i1 %58, i1 true, i1 %67
%195 = select i1 %194, i1 true, i1 %71
br i1 %195, label %224, label %196
196: ; preds = %190
%197 = insertelement <4 x i32> poison, i32 %193, i64 0
%198 = shufflevector <4 x i32> %197, <4 x i32> poison, <4 x i32> zeroinitializer
br label %199
199: ; preds = %199, %196
%200 = phi i64 [ 0, %196 ], [ %221, %199 ]
%201 = sub i64 %38, %200
%202 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %201
%203 = getelementptr inbounds i32, i32* %202, i64 -3
%204 = bitcast i32* %203 to <4 x i32>*
%205 = load <4 x i32>, <4 x i32>* %204
%206 = add nsw <4 x i32> %205, <i32 113, i32 113, i32 113, i32 113>
%207 = shufflevector <4 x i32> %206, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%208 = add i64 %201, 4294967295
%209 = and i64 %208, 4294967295
%210 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %209
%211 = getelementptr inbounds i32, i32* %210, i64 -3
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = shufflevector <4 x i32> %213, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%215 = mul nsw <4 x i32> %214, %198
%216 = srem <4 x i32> %215, <i32 113, i32 113, i32 113, i32 113>
%217 = sub <4 x i32> %207, %216
%218 = srem <4 x i32> %217, <i32 113, i32 113, i32 113, i32 113>
%219 = shufflevector <4 x i32> %218, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%220 = bitcast i32* %203 to <4 x i32>*
store <4 x i32> %219, <4 x i32>* %220
%221 = add nuw i64 %200, 4
%222 = icmp eq i64 %221, %72
br i1 %222, label %223, label %199
223: ; preds = %199
br i1 %74, label %241, label %224
224: ; preds = %190, %223
%225 = phi i64 [ %38, %190 ], [ %73, %223 ]
br label %226
226: ; preds = %224, %226
%227 = phi i64 [ %231, %226 ], [ %225, %224 ]
%228 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %227
%229 = load i32, i32* %228
%230 = add nsw i32 %229, 113
%231 = add nsw i64 %227, -1
%232 = and i64 %231, 4294967295
%233 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %232
%234 = load i32, i32* %233
%235 = mul nsw i32 %234, %193
%236 = srem i32 %235, 113
%237 = sub i32 %230, %236
%238 = srem i32 %237, 113
store i32 %238, i32* %228
%239 = trunc i64 %227 to i32
%240 = icmp sgt i32 %239, 1
br i1 %240, label %226, label %241
241: ; preds = %226, %223
%242 = add nuw nsw i64 %191, 1
%243 = icmp eq i64 %242, %41
br i1 %243, label %75, label %190
244: ; preds = %187, %269, %147, %169, %75
%245 = icmp sgt i32 %31, 0
br i1 %245, label %246, label %288
246: ; preds = %244
%247 = mul nsw i32 %31, %8
%248 = sext i32 %247 to i64
%249 = add nsw i64 %27, %248
%250 = getelementptr inbounds i8, i8* %2, i64 %249
%251 = add i32 %34, -1
%252 = icmp sgt i32 %34, 1
%253 = sext i32 %34 to i64
%254 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %253
%255 = load i32, i32* %254
%256 = add nsw i32 %33, -1
%257 = mul nsw i32 %256, %8
%258 = sext i32 %257 to i64
%259 = add nsw i64 %27, %258
%260 = getelementptr inbounds i8, i8* %2, i64 %259
%261 = zext i32 %31 to i64
%262 = call i32 @llvm.smax.i32(i32 %251, i32 1)
%263 = zext i32 %31 to i64
%264 = zext i32 %262 to i64
%265 = icmp ugt i32 %262, 3
%266 = select i1 %265, i1 %23, i1 false
%267 = and i64 %264, 2147483644
%268 = icmp eq i64 %267, %264
br label %400
269: ; preds = %187, %269
%270 = phi i64 [ %286, %269 ], [ %188, %187 ]
%271 = mul nsw i64 %270, %15
%272 = add nsw i64 %271, %27
%273 = getelementptr inbounds i8, i8* %2, i64 %272
store i8 0, i8* %273
%274 = add nsw i64 %270, 1
%275 = mul nsw i64 %274, %15
%276 = add nsw i64 %275, %27
%277 = getelementptr inbounds i8, i8* %2, i64 %276
store i8 0, i8* %277
%278 = add nsw i64 %270, 2
%279 = mul nsw i64 %278, %15
%280 = add nsw i64 %279, %27
%281 = getelementptr inbounds i8, i8* %2, i64 %280
store i8 0, i8* %281
%282 = add nsw i64 %270, 3
%283 = mul nsw i64 %282, %15
%284 = add nsw i64 %283, %27
%285 = getelementptr inbounds i8, i8* %2, i64 %284
store i8 0, i8* %285
%286 = add nsw i64 %270, 4
%287 = icmp eq i64 %286, %79
br i1 %287, label %244, label %269
288: ; preds = %469, %244
br i1 %76, label %289, label %498
289: ; preds = %288
%290 = sext i32 %31 to i64
%291 = sext i32 %33 to i64
%292 = sub nsw i64 %291, %290
%293 = icmp ugt i64 %292, 7
%294 = select i1 %293, i1 %25, i1 false
br i1 %294, label %295, label %380
295: ; preds = %289
%296 = icmp ult i64 %292, 16
br i1 %296, label %356, label %297
297: ; preds = %295
%298 = and i64 %292, -16
%299 = add nsw i64 %298, -16
%300 = lshr exact i64 %299, 4
%301 = add nuw nsw i64 %300, 1
%302 = and i64 %301, 1
%303 = icmp eq i64 %299, 0
br i1 %303, label %335, label %304
304: ; preds = %297
%305 = and i64 %301, 2305843009213693950
br label %306
306: ; preds = %306, %304
%307 = phi i64 [ 0, %304 ], [ %332, %306 ]
%308 = phi i64 [ 0, %304 ], [ %333, %306 ]
%309 = add i64 %307, %290
%310 = mul nsw i64 %309, %15
%311 = add nsw i64 %310, %27
%312 = getelementptr inbounds i8, i8* %2, i64 %311
%313 = bitcast i8* %312 to <16 x i8>*
%314 = load <16 x i8>, <16 x i8>* %313
%315 = zext <16 x i8> %314 to <16 x i16>
%316 = sub nsw <16 x i16> <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>, %315
%317 = srem <16 x i16> %316, <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>
%318 = trunc <16 x i16> %317 to <16 x i8>
%319 = bitcast i8* %312 to <16 x i8>*
store <16 x i8> %318, <16 x i8>* %319
%320 = or i64 %307, 16
%321 = add i64 %320, %290
%322 = mul nsw i64 %321, %15
%323 = add nsw i64 %322, %27
%324 = getelementptr inbounds i8, i8* %2, i64 %323
%325 = bitcast i8* %324 to <16 x i8>*
%326 = load <16 x i8>, <16 x i8>* %325
%327 = zext <16 x i8> %326 to <16 x i16>
%328 = sub nsw <16 x i16> <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>, %327
%329 = srem <16 x i16> %328, <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>
%330 = trunc <16 x i16> %329 to <16 x i8>
%331 = bitcast i8* %324 to <16 x i8>*
store <16 x i8> %330, <16 x i8>* %331
%332 = add nuw i64 %307, 32
%333 = add i64 %308, 2
%334 = icmp eq i64 %333, %305
br i1 %334, label %335, label %306
335: ; preds = %306, %297
%336 = phi i64 [ 0, %297 ], [ %332, %306 ]
%337 = icmp eq i64 %302, 0
br i1 %337, label %350, label %338
338: ; preds = %335
%339 = add i64 %336, %290
%340 = mul nsw i64 %339, %15
%341 = add nsw i64 %340, %27
%342 = getelementptr inbounds i8, i8* %2, i64 %341
%343 = bitcast i8* %342 to <16 x i8>*
%344 = load <16 x i8>, <16 x i8>* %343
%345 = zext <16 x i8> %344 to <16 x i16>
%346 = sub nsw <16 x i16> <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>, %345
%347 = srem <16 x i16> %346, <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>
%348 = trunc <16 x i16> %347 to <16 x i8>
%349 = bitcast i8* %342 to <16 x i8>*
store <16 x i8> %348, <16 x i8>* %349
br label %350
350: ; preds = %335, %338
%351 = icmp eq i64 %292, %298
br i1 %351, label %498, label %352
352: ; preds = %350
%353 = add nsw i64 %298, %290
%354 = and i64 %292, 8
%355 = icmp eq i64 %354, 0
br i1 %355, label %380, label %356
356: ; preds = %295, %352
%357 = phi i64 [ %298, %352 ], [ 0, %295 ]
%358 = sext i32 %33 to i64
%359 = sext i32 %31 to i64
%360 = sub nsw i64 %358, %359
%361 = and i64 %360, -8
%362 = add nsw i64 %361, %290
br label %363
363: ; preds = %363, %356
%364 = phi i64 [ %357, %356 ], [ %376, %363 ]
%365 = add i64 %364, %290
%366 = mul nsw i64 %365, %15
%367 = add nsw i64 %366, %27
%368 = getelementptr inbounds i8, i8* %2, i64 %367
%369 = bitcast i8* %368 to <8 x i8>*
%370 = load <8 x i8>, <8 x i8>* %369
%371 = zext <8 x i8> %370 to <8 x i16>
%372 = sub nsw <8 x i16> <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>, %371
%373 = srem <8 x i16> %372, <i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113, i16 113>
%374 = trunc <8 x i16> %373 to <8 x i8>
%375 = bitcast i8* %368 to <8 x i8>*
store <8 x i8> %374, <8 x i8>* %375
%376 = add nuw i64 %364, 8
%377 = icmp eq i64 %376, %361
br i1 %377, label %378, label %363
378: ; preds = %363
%379 = icmp eq i64 %360, %361
br i1 %379, label %498, label %380
380: ; preds = %289, %352, %378
%381 = phi i64 [ %290, %289 ], [ %353, %352 ], [ %362, %378 ]
%382 = sub nsw i64 %291, %381
%383 = xor i64 %381, -1
%384 = and i64 %382, 1
%385 = icmp eq i64 %384, 0
br i1 %385, label %396, label %386
386: ; preds = %380
%387 = mul nsw i64 %381, %15
%388 = add nsw i64 %387, %27
%389 = getelementptr inbounds i8, i8* %2, i64 %388
%390 = load i8, i8* %389
%391 = zext i8 %390 to i16
%392 = sub nsw i16 113, %391
%393 = srem i16 %392, 113
%394 = trunc i16 %393 to i8
store i8 %394, i8* %389
%395 = add nsw i64 %381, 1
br label %396
396: ; preds = %386, %380
%397 = phi i64 [ %381, %380 ], [ %395, %386 ]
%398 = sub nsw i64 0, %291
%399 = icmp eq i64 %383, %398
br i1 %399, label %498, label %477
400: ; preds = %246, %469
%401 = phi i64 [ 0, %246 ], [ %475, %469 ]
%402 = mul nsw i64 %401, %15
%403 = add nsw i64 %402, %27
%404 = getelementptr inbounds i8, i8* %2, i64 %403
%405 = load i8, i8* %404
%406 = zext i8 %405 to i16
%407 = load i8, i8* %250
%408 = zext i8 %407 to i16
%409 = add nuw nsw i16 %408, %406
%410 = urem i16 %409, 113
%411 = zext i16 %410 to i32
br i1 %252, label %412, label %469
412: ; preds = %400
br i1 %266, label %413, label %444
413: ; preds = %412
%414 = insertelement <4 x i32> poison, i32 %411, i64 0
%415 = shufflevector <4 x i32> %414, <4 x i32> poison, <4 x i32> zeroinitializer
br label %416
416: ; preds = %416, %413
%417 = phi i64 [ 0, %413 ], [ %441, %416 ]
%418 = or i64 %417, 1
%419 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %418
%420 = bitcast i32* %419 to <4 x i32>*
%421 = load <4 x i32>, <4 x i32>* %420
%422 = mul nsw <4 x i32> %421, %415
%423 = srem <4 x i32> %422, <i32 113, i32 113, i32 113, i32 113>
%424 = sub nsw <4 x i32> <i32 113, i32 113, i32 113, i32 113>, %423
%425 = add nuw nsw i64 %417, %261
%426 = add nuw nsw i64 %425, 1
%427 = mul nsw i64 %426, %15
%428 = add nsw i64 %427, %27
%429 = getelementptr inbounds i8, i8* %2, i64 %428
%430 = bitcast i8* %429 to <4 x i8>*
%431 = load <4 x i8>, <4 x i8>* %430
%432 = zext <4 x i8> %431 to <4 x i32>
%433 = add nuw nsw <4 x i32> %424, %432
%434 = trunc <4 x i32> %433 to <4 x i16>
%435 = urem <4 x i16> %434, <i16 113, i16 113, i16 113, i16 113>
%436 = trunc <4 x i16> %435 to <4 x i8>
%437 = mul nsw i64 %425, %15
%438 = add nsw i64 %437, %27
%439 = getelementptr inbounds i8, i8* %2, i64 %438
%440 = bitcast i8* %439 to <4 x i8>*
store <4 x i8> %436, <4 x i8>* %440
%441 = add nuw i64 %417, 4
%442 = icmp eq i64 %441, %267
br i1 %442, label %443, label %416
443: ; preds = %416
br i1 %268, label %469, label %444
444: ; preds = %412, %443
%445 = phi i64 [ 0, %412 ], [ %267, %443 ]
br label %446
446: ; preds = %444, %446
%447 = phi i64 [ %448, %446 ], [ %445, %444 ]
%448 = add nuw nsw i64 %447, 1
%449 = getelementptr inbounds [113 x i32], [113 x i32]* %4, i64 0, i64 %448
%450 = load i32, i32* %449
%451 = mul nsw i32 %450, %411
%452 = srem i32 %451, 113
%453 = sub nsw i32 113, %452
%454 = add nuw nsw i64 %447, %261
%455 = add nuw nsw i64 %454, 1
%456 = mul nsw i64 %455, %15
%457 = add nsw i64 %456, %27
%458 = getelementptr inbounds i8, i8* %2, i64 %457
%459 = load i8, i8* %458
%460 = zext i8 %459 to i32
%461 = add nuw nsw i32 %453, %460
%462 = trunc i32 %461 to i16
%463 = urem i16 %462, 113
%464 = trunc i16 %463 to i8
%465 = mul nsw i64 %454, %15
%466 = add nsw i64 %465, %27
%467 = getelementptr inbounds i8, i8* %2, i64 %466
store i8 %464, i8* %467
%468 = icmp eq i64 %448, %264
br i1 %468, label %469, label %446
469: ; preds = %446, %443, %400
%470 = mul nsw i32 %255, %411
%471 = srem i32 %470, 113
%472 = trunc i32 %471 to i8
%473 = sub i8 113, %472
%474 = urem i8 %473, 113
store i8 %474, i8* %260
%475 = add nuw nsw i64 %401, 1
%476 = icmp eq i64 %475, %263
br i1 %476, label %288, label %400
477: ; preds = %396, %477
%478 = phi i64 [ %496, %477 ], [ %397, %396 ]
%479 = mul nsw i64 %478, %15
%480 = add nsw i64 %479, %27
%481 = getelementptr inbounds i8, i8* %2, i64 %480
%482 = load i8, i8* %481
%483 = zext i8 %482 to i16
%484 = sub nsw i16 113, %483
%485 = srem i16 %484, 113
%486 = trunc i16 %485 to i8
store i8 %486, i8* %481
%487 = add nsw i64 %478, 1
%488 = mul nsw i64 %487, %15
%489 = add nsw i64 %488, %27
%490 = getelementptr inbounds i8, i8* %2, i64 %489
%491 = load i8, i8* %490
%492 = zext i8 %491 to i16
%493 = sub nsw i16 113, %492
%494 = srem i16 %493, 113
%495 = trunc i16 %494 to i8
store i8 %495, i8* %490
%496 = add nsw i64 %478, 2
%497 = icmp eq i64 %496, %291
br i1 %497, label %498, label %477
498: ; preds = %396, %477, %350, %378, %288
%499 = add nuw nsw i64 %27, 1
%500 = xor i32 %29, -1
%501 = icmp eq i64 %499, %17
br i1 %501, label %502, label %26
502: ; preds = %498, %3
ret void
}