#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(unsigned char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ prng_array_unshuffle(unsigned char *, unsigned int);
int decode_data(unsigned char *dst, int dst_len, unsigned char *src,
                int src_len, int rand) {
  int i, b, x;
  if ((dst_len << 3) != src_len)
    return (-1);
  if (rand == 1)
    prng_array_unshuffle(src, (unsigned int)src_len);
  x = 0;
  memset(dst, 0, dst_len);
  for (i = 0; i < dst_len; i++) {
    for (b = 0; b < 8; b++) {
      dst[i] = ((dst[i] & ~(1 << (7 - b))) | ((src[x] & 1) << (7 - b)));
      x++;
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<decode_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%eax
cmp    -0x24(%rbp),%eax
je     1155 <decode_data+0x35>
movl   $0xffffffff,-0x4(%rbp)
jmp    1221 <decode_data+0x101>
cmpl   $0x1,-0x28(%rbp)
jne    116b <decode_data+0x4b>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1030 <prng_array_unshuffle@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121a <decode_data+0xfa>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    1207 <decode_data+0xe7>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x7,%ecx
sub    -0x30(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%edx
and    $0x1,%edx
mov    $0x7,%ecx
sub    -0x30(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    119a <decode_data+0x7a>
jmp    120c <decode_data+0xec>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1187 <decode_data+0x67>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_data>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %esi,%r15d
lea    0x0(,%r15,8),%eax
mov    $0xffffffff,%ebp
cmp    %ecx,%eax
jne    123a <decode_data+0x11a>
mov    %rdx,%r14
mov    %rdi,%r12
cmp    $0x1,%r8d
jne    1156 <decode_data+0x36>
mov    %r14,%rdi
mov    %ecx,%esi
call   1030 <prng_array_unshuffle@plt>
xor    %ebp,%ebp
mov    %r12,%rdi
xor    %esi,%esi
mov    %r15d,%edx
call   1040 <memset@plt>
test   %r15d,%r15d
jle    123a <decode_data+0x11a>
mov    %r15d,%r8d
cmp    $0x8,%r15d
jae    1245 <decode_data+0x125>
xor    %edx,%edx
xor    %eax,%eax
nop
cltq
movzbl (%r12,%rdx,1),%ecx
and    $0x7f,%cl
movzbl (%r14,%rax,1),%ebx
shl    $0x7,%bl
or     %cl,%bl
mov    %bl,(%r12,%rdx,1)
and    $0xbf,%bl
movzbl 0x1(%r14,%rax,1),%ecx
shl    $0x6,%cl
and    $0x40,%cl
or     %bl,%cl
mov    %cl,(%r12,%rdx,1)
and    $0xdf,%cl
movzbl 0x2(%r14,%rax,1),%ebx
shl    $0x5,%bl
and    $0x20,%bl
or     %cl,%bl
mov    %bl,(%r12,%rdx,1)
and    $0xef,%bl
movzbl 0x3(%r14,%rax,1),%ecx
shl    $0x4,%cl
and    $0x10,%cl
or     %bl,%cl
mov    %cl,(%r12,%rdx,1)
and    $0xf7,%cl
movzbl 0x4(%r14,%rax,1),%ebx
shl    $0x3,%bl
and    $0x8,%bl
or     %cl,%bl
mov    %bl,(%r12,%rdx,1)
and    $0xfb,%bl
movzbl 0x5(%r14,%rax,1),%ecx
shl    $0x2,%cl
and    $0x4,%cl
or     %bl,%cl
mov    %cl,(%r12,%rdx,1)
and    $0xfd,%cl
movzbl 0x6(%r14,%rax,1),%ebx
add    %bl,%bl
and    $0x2,%bl
or     %cl,%bl
mov    %bl,(%r12,%rdx,1)
and    $0xfe,%bl
movzbl 0x7(%r14,%rax,1),%ecx
and    $0x1,%cl
or     %bl,%cl
mov    %cl,(%r12,%rdx,1)
add    $0x8,%rax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1180 <decode_data+0x60>
xor    %ebp,%ebp
mov    %ebp,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r8),%rcx
mov    $0x8,%edx
mov    %ecx,%eax
mul    %edx
seto   %dil
xor    %edx,%edx
test   %eax,%eax
js     16b2 <decode_data+0x592>
test   %dil,%dil
jne    16b9 <decode_data+0x599>
shr    $0x20,%rcx
mov    $0x0,%eax
jne    1180 <decode_data+0x60>
lea    (%r14,%r8,8),%rax
cmp    %r12,%rax
jbe    128e <decode_data+0x16e>
lea    (%r12,%r8,1),%rax
cmp    %r14,%rax
ja     117b <decode_data+0x5b>
cmp    $0x10,%r15d
jae    16c0 <decode_data+0x5a0>
xor    %edx,%edx
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    0x0(,%rdx,8),%rax
lea    0x3f(%r14),%rdi
movdqa 0xe78(%rip),%xmm12
movdqa 0xe7f(%rip),%xmm13
movdqa 0xe86(%rip),%xmm14
movdqa 0xe8d(%rip),%xmm15
movdqa 0xe94(%rip),%xmm10
movdqa 0xe9b(%rip),%xmm11
movdqa 0xea3(%rip),%xmm2
movdqa 0xeab(%rip),%xmm3
movdqa 0xeb3(%rip),%xmm4
movdqa 0xebb(%rip),%xmm5
movdqa 0xec3(%rip),%xmm6
movdqa 0xecb(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%r12,%rcx,1),%xmm0
pand   0xdd2(%rip),%xmm0
movzbl -0x3f(%rdi,%rcx,8),%r10d
movzbl -0x2f(%rdi,%rcx,8),%esi
movzbl -0x1f(%rdi,%rcx,8),%r9d
movzbl -0x27(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
movzbl -0x37(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %r10d,%esi
movd   %esi,%xmm8
pinsrw $0x1,%ebp,%xmm8
movzbl -0xf(%rdi,%rcx,8),%esi
movzbl -0x17(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm8
movzbl -0x7(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm8
psllw  $0x7,%xmm8
pand   0xc7c(%rip),%xmm8
por    %xmm0,%xmm8
movq   %xmm8,(%r12,%rcx,1)
pand   0xd68(%rip),%xmm8
movzbl -0x3e(%rdi,%rcx,8),%r10d
movzbl -0x2e(%rdi,%rcx,8),%ebp
movzbl -0x1e(%rdi,%rcx,8),%r9d
movzbl -0x26(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x36(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm9
pinsrw $0x1,%esi,%xmm9
movzbl -0xe(%rdi,%rcx,8),%esi
movzbl -0x16(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm9
movzbl -0x6(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm9
psllw  $0x6,%xmm9
pand   0xd12(%rip),%xmm9
por    %xmm8,%xmm9
movq   %xmm9,(%r12,%rcx,1)
pand   %xmm12,%xmm9
movzbl -0x3d(%rdi,%rcx,8),%r10d
movzbl -0x2d(%rdi,%rcx,8),%ebp
movzbl -0x1d(%rdi,%rcx,8),%r9d
movzbl -0x25(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x35(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm0
pinsrw $0x1,%esi,%xmm0
movzbl -0xd(%rdi,%rcx,8),%esi
movzbl -0x15(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm0
movzbl -0x5(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm0
psllw  $0x5,%xmm0
pand   %xmm13,%xmm0
por    %xmm9,%xmm0
movq   %xmm0,(%r12,%rcx,1)
pand   %xmm14,%xmm0
movzbl -0x3c(%rdi,%rcx,8),%r10d
movzbl -0x2c(%rdi,%rcx,8),%ebp
movzbl -0x1c(%rdi,%rcx,8),%r9d
movzbl -0x24(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x34(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm1
pinsrw $0x1,%esi,%xmm1
movzbl -0xc(%rdi,%rcx,8),%esi
movzbl -0x14(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm1
movzbl -0x4(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm1
psllw  $0x4,%xmm1
pand   %xmm15,%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%r12,%rcx,1)
pand   %xmm10,%xmm1
movzbl -0x3b(%rdi,%rcx,8),%r10d
movzbl -0x2b(%rdi,%rcx,8),%ebp
movzbl -0x1b(%rdi,%rcx,8),%r9d
movzbl -0x23(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x33(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm0
pinsrw $0x1,%esi,%xmm0
movzbl -0xb(%rdi,%rcx,8),%esi
movzbl -0x13(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm0
movzbl -0x3(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm0
psllw  $0x3,%xmm0
pand   %xmm11,%xmm0
por    %xmm1,%xmm0
movq   %xmm0,(%r12,%rcx,1)
pand   %xmm2,%xmm0
movzbl -0x3a(%rdi,%rcx,8),%r10d
movzbl -0x2a(%rdi,%rcx,8),%ebp
movzbl -0x1a(%rdi,%rcx,8),%r9d
movzbl -0x22(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x32(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm1
pinsrw $0x1,%esi,%xmm1
movzbl -0xa(%rdi,%rcx,8),%esi
movzbl -0x12(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm1
movzbl -0x2(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm1
psllw  $0x2,%xmm1
pand   %xmm3,%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%r12,%rcx,1)
pand   %xmm4,%xmm1
movzbl -0x39(%rdi,%rcx,8),%r10d
movzbl -0x29(%rdi,%rcx,8),%ebp
movzbl -0x19(%rdi,%rcx,8),%r9d
movzbl -0x21(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x31(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm0
pinsrw $0x1,%esi,%xmm0
movzbl -0x9(%rdi,%rcx,8),%esi
movzbl -0x11(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm0
movzbl -0x1(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm0
paddb  %xmm0,%xmm0
pand   %xmm5,%xmm0
por    %xmm1,%xmm0
movq   %xmm0,(%r12,%rcx,1)
pand   %xmm6,%xmm0
movzbl -0x38(%rdi,%rcx,8),%r10d
movzbl -0x28(%rdi,%rcx,8),%ebp
movzbl -0x18(%rdi,%rcx,8),%r9d
movzbl -0x20(%rdi,%rcx,8),%esi
shl    $0x8,%esi
or     %ebp,%esi
movzbl -0x30(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
movd   %ebp,%xmm1
pinsrw $0x1,%esi,%xmm1
movzbl -0x8(%rdi,%rcx,8),%esi
movzbl -0x10(%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %r9d,%ebp
pinsrw $0x2,%ebp,%xmm1
movzbl (%rdi,%rcx,8),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm1
pand   %xmm7,%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%r12,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1320 <decode_data+0x200>
xor    %ebp,%ebp
cmp    %r8,%rdx
jne    1180 <decode_data+0x60>
jmp    123a <decode_data+0x11a>
xor    %eax,%eax
jmp    1180 <decode_data+0x60>
xor    %eax,%eax
jmp    1180 <decode_data+0x60>
mov    %r8d,%edx
and    $0xfffffff0,%edx
lea    0x7f(%r14),%rax
xor    %ecx,%ecx
movdqa 0x9ab(%rip),%xmm10
movdqa 0x9b2(%rip),%xmm11
movdqa 0x9b9(%rip),%xmm12
movdqa 0x9c0(%rip),%xmm13
movdqa 0x9c7(%rip),%xmm14
movdqa 0x9ce(%rip),%xmm15
movdqa 0x9d6(%rip),%xmm6
movdqa 0x9de(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%r12,%rcx,1),%xmm0
pand   0x8d2(%rip),%xmm0
movzbl -0x7(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0xf(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x17(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x1f(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x27(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x2f(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x37(%rax,%rcx,8),%edi
movd   %edi,%xmm4
movzbl -0x3f(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm4,%xmm1
punpcklwd %xmm2,%xmm1
punpckldq %xmm3,%xmm1
movzbl -0x47(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x4f(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm2,%xmm3
movzbl -0x57(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x5f(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x67(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x6f(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm2,%xmm3
movzbl -0x77(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x7f(%rax,%rcx,8),%edi
movd   %edi,%xmm8
punpcklbw %xmm2,%xmm8
punpcklwd %xmm3,%xmm8
punpckldq %xmm4,%xmm8
punpcklqdq %xmm1,%xmm8
psllw  $0x7,%xmm8
pand   0x802(%rip),%xmm8
por    %xmm0,%xmm8
movdqu %xmm8,(%r12,%rcx,1)
pand   0x7fe(%rip),%xmm8
movzbl -0x6(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0xe(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm0,%xmm1
movzbl -0x16(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x1e(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl -0x26(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x2e(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm0,%xmm1
movzbl -0x36(%rax,%rcx,8),%edi
movd   %edi,%xmm3
movzbl -0x3e(%rax,%rcx,8),%edi
movd   %edi,%xmm0
punpcklbw %xmm3,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movzbl -0x46(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x4e(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x56(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x5e(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x66(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x6e(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x76(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x7e(%rax,%rcx,8),%edi
movd   %edi,%xmm9
punpcklbw %xmm1,%xmm9
punpcklwd %xmm2,%xmm9
punpckldq %xmm3,%xmm9
punpcklqdq %xmm0,%xmm9
psllw  $0x6,%xmm9
pand   0x72e(%rip),%xmm9
por    %xmm8,%xmm9
movdqu %xmm9,(%r12,%rcx,1)
pand   0x72a(%rip),%xmm9
movzbl -0x5(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0xd(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm0,%xmm1
movzbl -0x15(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x1d(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl -0x25(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x2d(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
movzbl -0x35(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x3d(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm0,%xmm1
punpcklwd %xmm3,%xmm1
punpckldq %xmm2,%xmm1
movzbl -0x45(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x4d(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
movzbl -0x55(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x5d(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x65(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x6d(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
movzbl -0x75(%rax,%rcx,8),%edi
movd   %edi,%xmm4
movzbl -0x7d(%rax,%rcx,8),%edi
movd   %edi,%xmm0
punpcklbw %xmm4,%xmm0
punpcklwd %xmm2,%xmm0
punpckldq %xmm3,%xmm0
punpcklqdq %xmm1,%xmm0
psllw  $0x5,%xmm0
pand   0x661(%rip),%xmm0
por    %xmm9,%xmm0
movdqu %xmm0,(%r12,%rcx,1)
pand   0x65e(%rip),%xmm0
movzbl -0x4(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0xc(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x14(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x1c(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x24(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x2c(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm1,%xmm4
movzbl -0x34(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x3c(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm4,%xmm2
punpckldq %xmm3,%xmm2
movzbl -0x44(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x4c(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
movzbl -0x54(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x5c(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x64(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x6c(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
movzbl -0x74(%rax,%rcx,8),%edi
movd   %edi,%xmm5
movzbl -0x7c(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm5,%xmm1
punpcklwd %xmm3,%xmm1
punpckldq %xmm4,%xmm1
punpcklqdq %xmm2,%xmm1
psllw  $0x4,%xmm1
pand   0x595(%rip),%xmm1
por    %xmm0,%xmm1
movdqu %xmm1,(%r12,%rcx,1)
pand   %xmm10,%xmm1
movzbl -0x3(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0xb(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
movzbl -0x13(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x1b(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x23(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x2b(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm0,%xmm4
movzbl -0x33(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x3b(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm4,%xmm2
punpckldq %xmm3,%xmm2
movzbl -0x43(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x4b(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
movzbl -0x53(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x5b(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x63(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x6b(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
movzbl -0x73(%rax,%rcx,8),%edi
movd   %edi,%xmm5
movzbl -0x7b(%rax,%rcx,8),%edi
movd   %edi,%xmm0
punpcklbw %xmm5,%xmm0
punpcklwd %xmm3,%xmm0
punpckldq %xmm4,%xmm0
punpcklqdq %xmm2,%xmm0
psllw  $0x3,%xmm0
pand   %xmm11,%xmm0
por    %xmm1,%xmm0
movdqu %xmm0,(%r12,%rcx,1)
pand   %xmm12,%xmm0
movzbl -0x2(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0xa(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x12(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x1a(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x22(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x2a(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm1,%xmm4
movzbl -0x32(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x3a(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm4,%xmm2
punpckldq %xmm3,%xmm2
movzbl -0x42(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x4a(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
movzbl -0x52(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x5a(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x62(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x6a(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
movzbl -0x72(%rax,%rcx,8),%edi
movd   %edi,%xmm5
movzbl -0x7a(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm5,%xmm1
punpcklwd %xmm3,%xmm1
punpckldq %xmm4,%xmm1
punpcklqdq %xmm2,%xmm1
psllw  $0x2,%xmm1
pand   %xmm13,%xmm1
por    %xmm0,%xmm1
movdqu %xmm1,(%r12,%rcx,1)
pand   %xmm14,%xmm1
movzbl -0x1(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x9(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
movzbl -0x11(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x19(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x21(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x29(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm0,%xmm4
movzbl -0x31(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x39(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm4,%xmm2
punpckldq %xmm3,%xmm2
movzbl -0x41(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x49(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
movzbl -0x51(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x59(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm0,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x61(%rax,%rcx,8),%edi
movd   %edi,%xmm0
movzbl -0x69(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm0,%xmm3
movzbl -0x71(%rax,%rcx,8),%edi
movd   %edi,%xmm5
movzbl -0x79(%rax,%rcx,8),%edi
movd   %edi,%xmm0
punpcklbw %xmm5,%xmm0
punpcklwd %xmm3,%xmm0
punpckldq %xmm4,%xmm0
punpcklqdq %xmm2,%xmm0
paddb  %xmm0,%xmm0
pand   %xmm15,%xmm0
por    %xmm1,%xmm0
movdqu %xmm0,(%r12,%rcx,1)
movzbl (%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x8(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x10(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x18(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl -0x20(%rax,%rcx,8),%edi
movd   %edi,%xmm1
movzbl -0x28(%rax,%rcx,8),%edi
movd   %edi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl -0x30(%rax,%rcx,8),%edi
movd   %edi,%xmm4
movzbl -0x38(%rax,%rcx,8),%edi
movd   %edi,%xmm1
punpcklbw %xmm4,%xmm1
punpcklwd %xmm2,%xmm1
punpckldq %xmm3,%xmm1
movzbl -0x40(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x48(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm2,%xmm3
movzbl -0x50(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x58(%rax,%rcx,8),%edi
movd   %edi,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm3,%xmm4
movzbl -0x60(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x68(%rax,%rcx,8),%edi
movd   %edi,%xmm3
punpcklbw %xmm2,%xmm3
movzbl -0x70(%rax,%rcx,8),%edi
movd   %edi,%xmm2
movzbl -0x78(%rax,%rcx,8),%edi
movd   %edi,%xmm5
punpcklbw %xmm2,%xmm5
punpcklwd %xmm3,%xmm5
punpckldq %xmm4,%xmm5
punpcklqdq %xmm1,%xmm5
pand   %xmm6,%xmm0
pand   %xmm7,%xmm5
por    %xmm0,%xmm5
movdqu %xmm5,(%r12,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%rdx
jne    1720 <decode_data+0x600>
xor    %ebp,%ebp
cmp    %r8,%rdx
je     123a <decode_data+0x11a>
test   $0x8,%r8b
jne    129a <decode_data+0x17a>
lea    0x0(,%rdx,8),%rax
jmp    1180 <decode_data+0x60>

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

LLVM IR (-O2):
define i32 @decode_data(i8* %0, i32 %1, i8* %2, i32 %3, i32 %4) {
%6 = shl i32 %1, 3
%7 = icmp eq i32 %6, %3
br i1 %7, label %8, label %975
8: ; preds = %5
%9 = icmp eq i32 %4, 1
br i1 %9, label %10, label %12
10: ; preds = %8
%11 = tail call i32 @prng_array_unshuffle(i8* %2, i32 %3)
br label %12
12: ; preds = %10, %8
%13 = tail call i32 @memset(i8* %0, i32 0, i32 %1)
%14 = icmp sgt i32 %1, 0
br i1 %14, label %15, label %975
15: ; preds = %12
%16 = zext i32 %1 to i64
%17 = icmp ult i32 %1, 8
br i1 %17, label %909, label %18
18: ; preds = %15
%19 = add nsw i64 %16, -1
%20 = trunc i64 %19 to i32
%21 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %20, i32 8)
%22 = extractvalue { i32, i1 } %21, 0
%23 = extractvalue { i32, i1 } %21, 1
%24 = icmp slt i32 %22, 0
%25 = or i1 %24, %23
%26 = icmp ugt i64 %19, 4294967295
%27 = or i1 %25, %26
br i1 %27, label %909, label %28
28: ; preds = %18
%29 = getelementptr i8, i8* %0, i64 %16
%30 = shl nuw nsw i64 %16, 3
%31 = getelementptr i8, i8* %2, i64 %30
%32 = icmp ugt i8* %31, %0
%33 = icmp ugt i8* %29, %2
%34 = and i1 %32, %33
br i1 %34, label %909, label %35
35: ; preds = %28
%36 = icmp ult i32 %1, 16
br i1 %36, label %602, label %37
37: ; preds = %35
%38 = and i64 %16, 4294967280
br label %39
39: ; preds = %39, %37
%40 = phi i64 [ 0, %37 ], [ %594, %39 ]
%41 = shl i64 %40, 3
%42 = or i64 %41, 8
%43 = or i64 %41, 16
%44 = or i64 %41, 24
%45 = or i64 %41, 32
%46 = or i64 %41, 40
%47 = or i64 %41, 48
%48 = or i64 %41, 56
%49 = or i64 %41, 64
%50 = or i64 %41, 72
%51 = or i64 %41, 80
%52 = or i64 %41, 88
%53 = or i64 %41, 96
%54 = or i64 %41, 104
%55 = or i64 %41, 112
%56 = or i64 %41, 120
%57 = getelementptr inbounds i8, i8* %0, i64 %40
%58 = bitcast i8* %57 to <16 x i8>*
%59 = load <16 x i8>, <16 x i8>* %58
%60 = and <16 x i8> %59, <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
%61 = getelementptr inbounds i8, i8* %2, i64 %41
%62 = getelementptr inbounds i8, i8* %2, i64 %42
%63 = getelementptr inbounds i8, i8* %2, i64 %43
%64 = getelementptr inbounds i8, i8* %2, i64 %44
%65 = getelementptr inbounds i8, i8* %2, i64 %45
%66 = getelementptr inbounds i8, i8* %2, i64 %46
%67 = getelementptr inbounds i8, i8* %2, i64 %47
%68 = getelementptr inbounds i8, i8* %2, i64 %48
%69 = getelementptr inbounds i8, i8* %2, i64 %49
%70 = getelementptr inbounds i8, i8* %2, i64 %50
%71 = getelementptr inbounds i8, i8* %2, i64 %51
%72 = getelementptr inbounds i8, i8* %2, i64 %52
%73 = getelementptr inbounds i8, i8* %2, i64 %53
%74 = getelementptr inbounds i8, i8* %2, i64 %54
%75 = getelementptr inbounds i8, i8* %2, i64 %55
%76 = getelementptr inbounds i8, i8* %2, i64 %56
%77 = load i8, i8* %61
%78 = load i8, i8* %62
%79 = load i8, i8* %63
%80 = load i8, i8* %64
%81 = load i8, i8* %65
%82 = load i8, i8* %66
%83 = load i8, i8* %67
%84 = load i8, i8* %68
%85 = load i8, i8* %69
%86 = load i8, i8* %70
%87 = load i8, i8* %71
%88 = load i8, i8* %72
%89 = load i8, i8* %73
%90 = load i8, i8* %74
%91 = load i8, i8* %75
%92 = load i8, i8* %76
%93 = insertelement <16 x i8> poison, i8 %77, i64 0
%94 = insertelement <16 x i8> %93, i8 %78, i64 1
%95 = insertelement <16 x i8> %94, i8 %79, i64 2
%96 = insertelement <16 x i8> %95, i8 %80, i64 3
%97 = insertelement <16 x i8> %96, i8 %81, i64 4
%98 = insertelement <16 x i8> %97, i8 %82, i64 5
%99 = insertelement <16 x i8> %98, i8 %83, i64 6
%100 = insertelement <16 x i8> %99, i8 %84, i64 7
%101 = insertelement <16 x i8> %100, i8 %85, i64 8
%102 = insertelement <16 x i8> %101, i8 %86, i64 9
%103 = insertelement <16 x i8> %102, i8 %87, i64 10
%104 = insertelement <16 x i8> %103, i8 %88, i64 11
%105 = insertelement <16 x i8> %104, i8 %89, i64 12
%106 = insertelement <16 x i8> %105, i8 %90, i64 13
%107 = insertelement <16 x i8> %106, i8 %91, i64 14
%108 = insertelement <16 x i8> %107, i8 %92, i64 15
%109 = shl <16 x i8> %108, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%110 = or <16 x i8> %109, %60
%111 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %110, <16 x i8>* %111
%112 = or i64 %41, 1
%113 = or i64 %41, 9
%114 = or i64 %41, 17
%115 = or i64 %41, 25
%116 = or i64 %41, 33
%117 = or i64 %41, 41
%118 = or i64 %41, 49
%119 = or i64 %41, 57
%120 = or i64 %41, 65
%121 = or i64 %41, 73
%122 = or i64 %41, 81
%123 = or i64 %41, 89
%124 = or i64 %41, 97
%125 = or i64 %41, 105
%126 = or i64 %41, 113
%127 = or i64 %41, 121
%128 = and <16 x i8> %110, <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>
%129 = getelementptr inbounds i8, i8* %2, i64 %112
%130 = getelementptr inbounds i8, i8* %2, i64 %113
%131 = getelementptr inbounds i8, i8* %2, i64 %114
%132 = getelementptr inbounds i8, i8* %2, i64 %115
%133 = getelementptr inbounds i8, i8* %2, i64 %116
%134 = getelementptr inbounds i8, i8* %2, i64 %117
%135 = getelementptr inbounds i8, i8* %2, i64 %118
%136 = getelementptr inbounds i8, i8* %2, i64 %119
%137 = getelementptr inbounds i8, i8* %2, i64 %120
%138 = getelementptr inbounds i8, i8* %2, i64 %121
%139 = getelementptr inbounds i8, i8* %2, i64 %122
%140 = getelementptr inbounds i8, i8* %2, i64 %123
%141 = getelementptr inbounds i8, i8* %2, i64 %124
%142 = getelementptr inbounds i8, i8* %2, i64 %125
%143 = getelementptr inbounds i8, i8* %2, i64 %126
%144 = getelementptr inbounds i8, i8* %2, i64 %127
%145 = load i8, i8* %129
%146 = load i8, i8* %130
%147 = load i8, i8* %131
%148 = load i8, i8* %132
%149 = load i8, i8* %133
%150 = load i8, i8* %134
%151 = load i8, i8* %135
%152 = load i8, i8* %136
%153 = load i8, i8* %137
%154 = load i8, i8* %138
%155 = load i8, i8* %139
%156 = load i8, i8* %140
%157 = load i8, i8* %141
%158 = load i8, i8* %142
%159 = load i8, i8* %143
%160 = load i8, i8* %144
%161 = insertelement <16 x i8> poison, i8 %145, i64 0
%162 = insertelement <16 x i8> %161, i8 %146, i64 1
%163 = insertelement <16 x i8> %162, i8 %147, i64 2
%164 = insertelement <16 x i8> %163, i8 %148, i64 3
%165 = insertelement <16 x i8> %164, i8 %149, i64 4
%166 = insertelement <16 x i8> %165, i8 %150, i64 5
%167 = insertelement <16 x i8> %166, i8 %151, i64 6
%168 = insertelement <16 x i8> %167, i8 %152, i64 7
%169 = insertelement <16 x i8> %168, i8 %153, i64 8
%170 = insertelement <16 x i8> %169, i8 %154, i64 9
%171 = insertelement <16 x i8> %170, i8 %155, i64 10
%172 = insertelement <16 x i8> %171, i8 %156, i64 11
%173 = insertelement <16 x i8> %172, i8 %157, i64 12
%174 = insertelement <16 x i8> %173, i8 %158, i64 13
%175 = insertelement <16 x i8> %174, i8 %159, i64 14
%176 = insertelement <16 x i8> %175, i8 %160, i64 15
%177 = shl <16 x i8> %176, <i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6>
%178 = and <16 x i8> %177, <i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64>
%179 = or <16 x i8> %178, %128
%180 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %180
%181 = or i64 %41, 2
%182 = or i64 %41, 10
%183 = or i64 %41, 18
%184 = or i64 %41, 26
%185 = or i64 %41, 34
%186 = or i64 %41, 42
%187 = or i64 %41, 50
%188 = or i64 %41, 58
%189 = or i64 %41, 66
%190 = or i64 %41, 74
%191 = or i64 %41, 82
%192 = or i64 %41, 90
%193 = or i64 %41, 98
%194 = or i64 %41, 106
%195 = or i64 %41, 114
%196 = or i64 %41, 122
%197 = and <16 x i8> %179, <i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33>
%198 = getelementptr inbounds i8, i8* %2, i64 %181
%199 = getelementptr inbounds i8, i8* %2, i64 %182
%200 = getelementptr inbounds i8, i8* %2, i64 %183
%201 = getelementptr inbounds i8, i8* %2, i64 %184
%202 = getelementptr inbounds i8, i8* %2, i64 %185
%203 = getelementptr inbounds i8, i8* %2, i64 %186
%204 = getelementptr inbounds i8, i8* %2, i64 %187
%205 = getelementptr inbounds i8, i8* %2, i64 %188
%206 = getelementptr inbounds i8, i8* %2, i64 %189
%207 = getelementptr inbounds i8, i8* %2, i64 %190
%208 = getelementptr inbounds i8, i8* %2, i64 %191
%209 = getelementptr inbounds i8, i8* %2, i64 %192
%210 = getelementptr inbounds i8, i8* %2, i64 %193
%211 = getelementptr inbounds i8, i8* %2, i64 %194
%212 = getelementptr inbounds i8, i8* %2, i64 %195
%213 = getelementptr inbounds i8, i8* %2, i64 %196
%214 = load i8, i8* %198
%215 = load i8, i8* %199
%216 = load i8, i8* %200
%217 = load i8, i8* %201
%218 = load i8, i8* %202
%219 = load i8, i8* %203
%220 = load i8, i8* %204
%221 = load i8, i8* %205
%222 = load i8, i8* %206
%223 = load i8, i8* %207
%224 = load i8, i8* %208
%225 = load i8, i8* %209
%226 = load i8, i8* %210
%227 = load i8, i8* %211
%228 = load i8, i8* %212
%229 = load i8, i8* %213
%230 = insertelement <16 x i8> poison, i8 %214, i64 0
%231 = insertelement <16 x i8> %230, i8 %215, i64 1
%232 = insertelement <16 x i8> %231, i8 %216, i64 2
%233 = insertelement <16 x i8> %232, i8 %217, i64 3
%234 = insertelement <16 x i8> %233, i8 %218, i64 4
%235 = insertelement <16 x i8> %234, i8 %219, i64 5
%236 = insertelement <16 x i8> %235, i8 %220, i64 6
%237 = insertelement <16 x i8> %236, i8 %221, i64 7
%238 = insertelement <16 x i8> %237, i8 %222, i64 8
%239 = insertelement <16 x i8> %238, i8 %223, i64 9
%240 = insertelement <16 x i8> %239, i8 %224, i64 10
%241 = insertelement <16 x i8> %240, i8 %225, i64 11
%242 = insertelement <16 x i8> %241, i8 %226, i64 12
%243 = insertelement <16 x i8> %242, i8 %227, i64 13
%244 = insertelement <16 x i8> %243, i8 %228, i64 14
%245 = insertelement <16 x i8> %244, i8 %229, i64 15
%246 = shl <16 x i8> %245, <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
%247 = and <16 x i8> %246, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%248 = or <16 x i8> %247, %197
%249 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %248, <16 x i8>* %249
%250 = or i64 %41, 3
%251 = or i64 %41, 11
%252 = or i64 %41, 19
%253 = or i64 %41, 27
%254 = or i64 %41, 35
%255 = or i64 %41, 43
%256 = or i64 %41, 51
%257 = or i64 %41, 59
%258 = or i64 %41, 67
%259 = or i64 %41, 75
%260 = or i64 %41, 83
%261 = or i64 %41, 91
%262 = or i64 %41, 99
%263 = or i64 %41, 107
%264 = or i64 %41, 115
%265 = or i64 %41, 123
%266 = and <16 x i8> %248, <i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17>
%267 = getelementptr inbounds i8, i8* %2, i64 %250
%268 = getelementptr inbounds i8, i8* %2, i64 %251
%269 = getelementptr inbounds i8, i8* %2, i64 %252
%270 = getelementptr inbounds i8, i8* %2, i64 %253
%271 = getelementptr inbounds i8, i8* %2, i64 %254
%272 = getelementptr inbounds i8, i8* %2, i64 %255
%273 = getelementptr inbounds i8, i8* %2, i64 %256
%274 = getelementptr inbounds i8, i8* %2, i64 %257
%275 = getelementptr inbounds i8, i8* %2, i64 %258
%276 = getelementptr inbounds i8, i8* %2, i64 %259
%277 = getelementptr inbounds i8, i8* %2, i64 %260
%278 = getelementptr inbounds i8, i8* %2, i64 %261
%279 = getelementptr inbounds i8, i8* %2, i64 %262
%280 = getelementptr inbounds i8, i8* %2, i64 %263
%281 = getelementptr inbounds i8, i8* %2, i64 %264
%282 = getelementptr inbounds i8, i8* %2, i64 %265
%283 = load i8, i8* %267
%284 = load i8, i8* %268
%285 = load i8, i8* %269
%286 = load i8, i8* %270
%287 = load i8, i8* %271
%288 = load i8, i8* %272
%289 = load i8, i8* %273
%290 = load i8, i8* %274
%291 = load i8, i8* %275
%292 = load i8, i8* %276
%293 = load i8, i8* %277
%294 = load i8, i8* %278
%295 = load i8, i8* %279
%296 = load i8, i8* %280
%297 = load i8, i8* %281
%298 = load i8, i8* %282
%299 = insertelement <16 x i8> poison, i8 %283, i64 0
%300 = insertelement <16 x i8> %299, i8 %284, i64 1
%301 = insertelement <16 x i8> %300, i8 %285, i64 2
%302 = insertelement <16 x i8> %301, i8 %286, i64 3
%303 = insertelement <16 x i8> %302, i8 %287, i64 4
%304 = insertelement <16 x i8> %303, i8 %288, i64 5
%305 = insertelement <16 x i8> %304, i8 %289, i64 6
%306 = insertelement <16 x i8> %305, i8 %290, i64 7
%307 = insertelement <16 x i8> %306, i8 %291, i64 8
%308 = insertelement <16 x i8> %307, i8 %292, i64 9
%309 = insertelement <16 x i8> %308, i8 %293, i64 10
%310 = insertelement <16 x i8> %309, i8 %294, i64 11
%311 = insertelement <16 x i8> %310, i8 %295, i64 12
%312 = insertelement <16 x i8> %311, i8 %296, i64 13
%313 = insertelement <16 x i8> %312, i8 %297, i64 14
%314 = insertelement <16 x i8> %313, i8 %298, i64 15
%315 = shl <16 x i8> %314, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%316 = and <16 x i8> %315, <i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16>
%317 = or <16 x i8> %316, %266
%318 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %317, <16 x i8>* %318
%319 = or i64 %41, 4
%320 = or i64 %41, 12
%321 = or i64 %41, 20
%322 = or i64 %41, 28
%323 = or i64 %41, 36
%324 = or i64 %41, 44
%325 = or i64 %41, 52
%326 = or i64 %41, 60
%327 = or i64 %41, 68
%328 = or i64 %41, 76
%329 = or i64 %41, 84
%330 = or i64 %41, 92
%331 = or i64 %41, 100
%332 = or i64 %41, 108
%333 = or i64 %41, 116
%334 = or i64 %41, 124
%335 = and <16 x i8> %317, <i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9>
%336 = getelementptr inbounds i8, i8* %2, i64 %319
%337 = getelementptr inbounds i8, i8* %2, i64 %320
%338 = getelementptr inbounds i8, i8* %2, i64 %321
%339 = getelementptr inbounds i8, i8* %2, i64 %322
%340 = getelementptr inbounds i8, i8* %2, i64 %323
%341 = getelementptr inbounds i8, i8* %2, i64 %324
%342 = getelementptr inbounds i8, i8* %2, i64 %325
%343 = getelementptr inbounds i8, i8* %2, i64 %326
%344 = getelementptr inbounds i8, i8* %2, i64 %327
%345 = getelementptr inbounds i8, i8* %2, i64 %328
%346 = getelementptr inbounds i8, i8* %2, i64 %329
%347 = getelementptr inbounds i8, i8* %2, i64 %330
%348 = getelementptr inbounds i8, i8* %2, i64 %331
%349 = getelementptr inbounds i8, i8* %2, i64 %332
%350 = getelementptr inbounds i8, i8* %2, i64 %333
%351 = getelementptr inbounds i8, i8* %2, i64 %334
%352 = load i8, i8* %336
%353 = load i8, i8* %337
%354 = load i8, i8* %338
%355 = load i8, i8* %339
%356 = load i8, i8* %340
%357 = load i8, i8* %341
%358 = load i8, i8* %342
%359 = load i8, i8* %343
%360 = load i8, i8* %344
%361 = load i8, i8* %345
%362 = load i8, i8* %346
%363 = load i8, i8* %347
%364 = load i8, i8* %348
%365 = load i8, i8* %349
%366 = load i8, i8* %350
%367 = load i8, i8* %351
%368 = insertelement <16 x i8> poison, i8 %352, i64 0
%369 = insertelement <16 x i8> %368, i8 %353, i64 1
%370 = insertelement <16 x i8> %369, i8 %354, i64 2
%371 = insertelement <16 x i8> %370, i8 %355, i64 3
%372 = insertelement <16 x i8> %371, i8 %356, i64 4
%373 = insertelement <16 x i8> %372, i8 %357, i64 5
%374 = insertelement <16 x i8> %373, i8 %358, i64 6
%375 = insertelement <16 x i8> %374, i8 %359, i64 7
%376 = insertelement <16 x i8> %375, i8 %360, i64 8
%377 = insertelement <16 x i8> %376, i8 %361, i64 9
%378 = insertelement <16 x i8> %377, i8 %362, i64 10
%379 = insertelement <16 x i8> %378, i8 %363, i64 11
%380 = insertelement <16 x i8> %379, i8 %364, i64 12
%381 = insertelement <16 x i8> %380, i8 %365, i64 13
%382 = insertelement <16 x i8> %381, i8 %366, i64 14
%383 = insertelement <16 x i8> %382, i8 %367, i64 15
%384 = shl <16 x i8> %383, <i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3>
%385 = and <16 x i8> %384, <i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8>
%386 = or <16 x i8> %385, %335
%387 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %386, <16 x i8>* %387
%388 = or i64 %41, 5
%389 = or i64 %41, 13
%390 = or i64 %41, 21
%391 = or i64 %41, 29
%392 = or i64 %41, 37
%393 = or i64 %41, 45
%394 = or i64 %41, 53
%395 = or i64 %41, 61
%396 = or i64 %41, 69
%397 = or i64 %41, 77
%398 = or i64 %41, 85
%399 = or i64 %41, 93
%400 = or i64 %41, 101
%401 = or i64 %41, 109
%402 = or i64 %41, 117
%403 = or i64 %41, 125
%404 = and <16 x i8> %386, <i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5>
%405 = getelementptr inbounds i8, i8* %2, i64 %388
%406 = getelementptr inbounds i8, i8* %2, i64 %389
%407 = getelementptr inbounds i8, i8* %2, i64 %390
%408 = getelementptr inbounds i8, i8* %2, i64 %391
%409 = getelementptr inbounds i8, i8* %2, i64 %392
%410 = getelementptr inbounds i8, i8* %2, i64 %393
%411 = getelementptr inbounds i8, i8* %2, i64 %394
%412 = getelementptr inbounds i8, i8* %2, i64 %395
%413 = getelementptr inbounds i8, i8* %2, i64 %396
%414 = getelementptr inbounds i8, i8* %2, i64 %397
%415 = getelementptr inbounds i8, i8* %2, i64 %398
%416 = getelementptr inbounds i8, i8* %2, i64 %399
%417 = getelementptr inbounds i8, i8* %2, i64 %400
%418 = getelementptr inbounds i8, i8* %2, i64 %401
%419 = getelementptr inbounds i8, i8* %2, i64 %402
%420 = getelementptr inbounds i8, i8* %2, i64 %403
%421 = load i8, i8* %405
%422 = load i8, i8* %406
%423 = load i8, i8* %407
%424 = load i8, i8* %408
%425 = load i8, i8* %409
%426 = load i8, i8* %410
%427 = load i8, i8* %411
%428 = load i8, i8* %412
%429 = load i8, i8* %413
%430 = load i8, i8* %414
%431 = load i8, i8* %415
%432 = load i8, i8* %416
%433 = load i8, i8* %417
%434 = load i8, i8* %418
%435 = load i8, i8* %419
%436 = load i8, i8* %420
%437 = insertelement <16 x i8> poison, i8 %421, i64 0
%438 = insertelement <16 x i8> %437, i8 %422, i64 1
%439 = insertelement <16 x i8> %438, i8 %423, i64 2
%440 = insertelement <16 x i8> %439, i8 %424, i64 3
%441 = insertelement <16 x i8> %440, i8 %425, i64 4
%442 = insertelement <16 x i8> %441, i8 %426, i64 5
%443 = insertelement <16 x i8> %442, i8 %427, i64 6
%444 = insertelement <16 x i8> %443, i8 %428, i64 7
%445 = insertelement <16 x i8> %444, i8 %429, i64 8
%446 = insertelement <16 x i8> %445, i8 %430, i64 9
%447 = insertelement <16 x i8> %446, i8 %431, i64 10
%448 = insertelement <16 x i8> %447, i8 %432, i64 11
%449 = insertelement <16 x i8> %448, i8 %433, i64 12
%450 = insertelement <16 x i8> %449, i8 %434, i64 13
%451 = insertelement <16 x i8> %450, i8 %435, i64 14
%452 = insertelement <16 x i8> %451, i8 %436, i64 15
%453 = shl <16 x i8> %452, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%454 = and <16 x i8> %453, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%455 = or <16 x i8> %454, %404
%456 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %455, <16 x i8>* %456
%457 = or i64 %41, 6
%458 = or i64 %41, 14
%459 = or i64 %41, 22
%460 = or i64 %41, 30
%461 = or i64 %41, 38
%462 = or i64 %41, 46
%463 = or i64 %41, 54
%464 = or i64 %41, 62
%465 = or i64 %41, 70
%466 = or i64 %41, 78
%467 = or i64 %41, 86
%468 = or i64 %41, 94
%469 = or i64 %41, 102
%470 = or i64 %41, 110
%471 = or i64 %41, 118
%472 = or i64 %41, 126
%473 = and <16 x i8> %455, <i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3>
%474 = getelementptr inbounds i8, i8* %2, i64 %457
%475 = getelementptr inbounds i8, i8* %2, i64 %458
%476 = getelementptr inbounds i8, i8* %2, i64 %459
%477 = getelementptr inbounds i8, i8* %2, i64 %460
%478 = getelementptr inbounds i8, i8* %2, i64 %461
%479 = getelementptr inbounds i8, i8* %2, i64 %462
%480 = getelementptr inbounds i8, i8* %2, i64 %463
%481 = getelementptr inbounds i8, i8* %2, i64 %464
%482 = getelementptr inbounds i8, i8* %2, i64 %465
%483 = getelementptr inbounds i8, i8* %2, i64 %466
%484 = getelementptr inbounds i8, i8* %2, i64 %467
%485 = getelementptr inbounds i8, i8* %2, i64 %468
%486 = getelementptr inbounds i8, i8* %2, i64 %469
%487 = getelementptr inbounds i8, i8* %2, i64 %470
%488 = getelementptr inbounds i8, i8* %2, i64 %471
%489 = getelementptr inbounds i8, i8* %2, i64 %472
%490 = load i8, i8* %474
%491 = load i8, i8* %475
%492 = load i8, i8* %476
%493 = load i8, i8* %477
%494 = load i8, i8* %478
%495 = load i8, i8* %479
%496 = load i8, i8* %480
%497 = load i8, i8* %481
%498 = load i8, i8* %482
%499 = load i8, i8* %483
%500 = load i8, i8* %484
%501 = load i8, i8* %485
%502 = load i8, i8* %486
%503 = load i8, i8* %487
%504 = load i8, i8* %488
%505 = load i8, i8* %489
%506 = insertelement <16 x i8> poison, i8 %490, i64 0
%507 = insertelement <16 x i8> %506, i8 %491, i64 1
%508 = insertelement <16 x i8> %507, i8 %492, i64 2
%509 = insertelement <16 x i8> %508, i8 %493, i64 3
%510 = insertelement <16 x i8> %509, i8 %494, i64 4
%511 = insertelement <16 x i8> %510, i8 %495, i64 5
%512 = insertelement <16 x i8> %511, i8 %496, i64 6
%513 = insertelement <16 x i8> %512, i8 %497, i64 7
%514 = insertelement <16 x i8> %513, i8 %498, i64 8
%515 = insertelement <16 x i8> %514, i8 %499, i64 9
%516 = insertelement <16 x i8> %515, i8 %500, i64 10
%517 = insertelement <16 x i8> %516, i8 %501, i64 11
%518 = insertelement <16 x i8> %517, i8 %502, i64 12
%519 = insertelement <16 x i8> %518, i8 %503, i64 13
%520 = insertelement <16 x i8> %519, i8 %504, i64 14
%521 = insertelement <16 x i8> %520, i8 %505, i64 15
%522 = shl <16 x i8> %521, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%523 = and <16 x i8> %522, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%524 = or <16 x i8> %523, %473
%525 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %524, <16 x i8>* %525
%526 = or i64 %41, 7
%527 = or i64 %41, 15
%528 = or i64 %41, 23
%529 = or i64 %41, 31
%530 = or i64 %41, 39
%531 = or i64 %41, 47
%532 = or i64 %41, 55
%533 = or i64 %41, 63
%534 = or i64 %41, 71
%535 = or i64 %41, 79
%536 = or i64 %41, 87
%537 = or i64 %41, 95
%538 = or i64 %41, 103
%539 = or i64 %41, 111
%540 = or i64 %41, 119
%541 = or i64 %41, 127
%542 = and <16 x i8> %524, <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2>
%543 = getelementptr inbounds i8, i8* %2, i64 %526
%544 = getelementptr inbounds i8, i8* %2, i64 %527
%545 = getelementptr inbounds i8, i8* %2, i64 %528
%546 = getelementptr inbounds i8, i8* %2, i64 %529
%547 = getelementptr inbounds i8, i8* %2, i64 %530
%548 = getelementptr inbounds i8, i8* %2, i64 %531
%549 = getelementptr inbounds i8, i8* %2, i64 %532
%550 = getelementptr inbounds i8, i8* %2, i64 %533
%551 = getelementptr inbounds i8, i8* %2, i64 %534
%552 = getelementptr inbounds i8, i8* %2, i64 %535
%553 = getelementptr inbounds i8, i8* %2, i64 %536
%554 = getelementptr inbounds i8, i8* %2, i64 %537
%555 = getelementptr inbounds i8, i8* %2, i64 %538
%556 = getelementptr inbounds i8, i8* %2, i64 %539
%557 = getelementptr inbounds i8, i8* %2, i64 %540
%558 = getelementptr inbounds i8, i8* %2, i64 %541
%559 = load i8, i8* %543
%560 = load i8, i8* %544
%561 = load i8, i8* %545
%562 = load i8, i8* %546
%563 = load i8, i8* %547
%564 = load i8, i8* %548
%565 = load i8, i8* %549
%566 = load i8, i8* %550
%567 = load i8, i8* %551
%568 = load i8, i8* %552
%569 = load i8, i8* %553
%570 = load i8, i8* %554
%571 = load i8, i8* %555
%572 = load i8, i8* %556
%573 = load i8, i8* %557
%574 = load i8, i8* %558
%575 = insertelement <16 x i8> poison, i8 %559, i64 0
%576 = insertelement <16 x i8> %575, i8 %560, i64 1
%577 = insertelement <16 x i8> %576, i8 %561, i64 2
%578 = insertelement <16 x i8> %577, i8 %562, i64 3
%579 = insertelement <16 x i8> %578, i8 %563, i64 4
%580 = insertelement <16 x i8> %579, i8 %564, i64 5
%581 = insertelement <16 x i8> %580, i8 %565, i64 6
%582 = insertelement <16 x i8> %581, i8 %566, i64 7
%583 = insertelement <16 x i8> %582, i8 %567, i64 8
%584 = insertelement <16 x i8> %583, i8 %568, i64 9
%585 = insertelement <16 x i8> %584, i8 %569, i64 10
%586 = insertelement <16 x i8> %585, i8 %570, i64 11
%587 = insertelement <16 x i8> %586, i8 %571, i64 12
%588 = insertelement <16 x i8> %587, i8 %572, i64 13
%589 = insertelement <16 x i8> %588, i8 %573, i64 14
%590 = insertelement <16 x i8> %589, i8 %574, i64 15
%591 = and <16 x i8> %590, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%592 = or <16 x i8> %591, %542
%593 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %592, <16 x i8>* %593
%594 = add nuw i64 %40, 16
%595 = icmp eq i64 %594, %38
br i1 %595, label %596, label %39
596: ; preds = %39
%597 = icmp eq i64 %38, %16
br i1 %597, label %975, label %598
598: ; preds = %596
%599 = shl nuw nsw i64 %38, 3
%600 = and i64 %16, 8
%601 = icmp eq i64 %600, 0
br i1 %601, label %909, label %602
602: ; preds = %35, %598
%603 = phi i64 [ %38, %598 ], [ 0, %35 ]
%604 = and i64 %16, 4294967288
%605 = shl nuw nsw i64 %604, 3
br label %606
606: ; preds = %606, %602
%607 = phi i64 [ %603, %602 ], [ %905, %606 ]
%608 = shl i64 %607, 3
%609 = or i64 %608, 8
%610 = or i64 %608, 16
%611 = or i64 %608, 24
%612 = or i64 %608, 32
%613 = or i64 %608, 40
%614 = or i64 %608, 48
%615 = or i64 %608, 56
%616 = getelementptr inbounds i8, i8* %0, i64 %607
%617 = bitcast i8* %616 to <8 x i8>*
%618 = load <8 x i8>, <8 x i8>* %617
%619 = and <8 x i8> %618, <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
%620 = getelementptr inbounds i8, i8* %2, i64 %608
%621 = getelementptr inbounds i8, i8* %2, i64 %609
%622 = getelementptr inbounds i8, i8* %2, i64 %610
%623 = getelementptr inbounds i8, i8* %2, i64 %611
%624 = getelementptr inbounds i8, i8* %2, i64 %612
%625 = getelementptr inbounds i8, i8* %2, i64 %613
%626 = getelementptr inbounds i8, i8* %2, i64 %614
%627 = getelementptr inbounds i8, i8* %2, i64 %615
%628 = load i8, i8* %620
%629 = load i8, i8* %621
%630 = load i8, i8* %622
%631 = load i8, i8* %623
%632 = load i8, i8* %624
%633 = load i8, i8* %625
%634 = load i8, i8* %626
%635 = load i8, i8* %627
%636 = insertelement <8 x i8> poison, i8 %628, i64 0
%637 = insertelement <8 x i8> %636, i8 %629, i64 1
%638 = insertelement <8 x i8> %637, i8 %630, i64 2
%639 = insertelement <8 x i8> %638, i8 %631, i64 3
%640 = insertelement <8 x i8> %639, i8 %632, i64 4
%641 = insertelement <8 x i8> %640, i8 %633, i64 5
%642 = insertelement <8 x i8> %641, i8 %634, i64 6
%643 = insertelement <8 x i8> %642, i8 %635, i64 7
%644 = shl <8 x i8> %643, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%645 = or <8 x i8> %644, %619
%646 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %645, <8 x i8>* %646
%647 = or i64 %608, 1
%648 = or i64 %608, 9
%649 = or i64 %608, 17
%650 = or i64 %608, 25
%651 = or i64 %608, 33
%652 = or i64 %608, 41
%653 = or i64 %608, 49
%654 = or i64 %608, 57
%655 = and <8 x i8> %645, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%656 = getelementptr inbounds i8, i8* %2, i64 %647
%657 = getelementptr inbounds i8, i8* %2, i64 %648
%658 = getelementptr inbounds i8, i8* %2, i64 %649
%659 = getelementptr inbounds i8, i8* %2, i64 %650
%660 = getelementptr inbounds i8, i8* %2, i64 %651
%661 = getelementptr inbounds i8, i8* %2, i64 %652
%662 = getelementptr inbounds i8, i8* %2, i64 %653
%663 = getelementptr inbounds i8, i8* %2, i64 %654
%664 = load i8, i8* %656
%665 = load i8, i8* %657
%666 = load i8, i8* %658
%667 = load i8, i8* %659
%668 = load i8, i8* %660
%669 = load i8, i8* %661
%670 = load i8, i8* %662
%671 = load i8, i8* %663
%672 = insertelement <8 x i8> poison, i8 %664, i64 0
%673 = insertelement <8 x i8> %672, i8 %665, i64 1
%674 = insertelement <8 x i8> %673, i8 %666, i64 2
%675 = insertelement <8 x i8> %674, i8 %667, i64 3
%676 = insertelement <8 x i8> %675, i8 %668, i64 4
%677 = insertelement <8 x i8> %676, i8 %669, i64 5
%678 = insertelement <8 x i8> %677, i8 %670, i64 6
%679 = insertelement <8 x i8> %678, i8 %671, i64 7
%680 = shl <8 x i8> %679, <i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6>
%681 = and <8 x i8> %680, <i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64>
%682 = or <8 x i8> %681, %655
%683 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %682, <8 x i8>* %683
%684 = or i64 %608, 2
%685 = or i64 %608, 10
%686 = or i64 %608, 18
%687 = or i64 %608, 26
%688 = or i64 %608, 34
%689 = or i64 %608, 42
%690 = or i64 %608, 50
%691 = or i64 %608, 58
%692 = and <8 x i8> %682, <i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33, i8 -33>
%693 = getelementptr inbounds i8, i8* %2, i64 %684
%694 = getelementptr inbounds i8, i8* %2, i64 %685
%695 = getelementptr inbounds i8, i8* %2, i64 %686
%696 = getelementptr inbounds i8, i8* %2, i64 %687
%697 = getelementptr inbounds i8, i8* %2, i64 %688
%698 = getelementptr inbounds i8, i8* %2, i64 %689
%699 = getelementptr inbounds i8, i8* %2, i64 %690
%700 = getelementptr inbounds i8, i8* %2, i64 %691
%701 = load i8, i8* %693
%702 = load i8, i8* %694
%703 = load i8, i8* %695
%704 = load i8, i8* %696
%705 = load i8, i8* %697
%706 = load i8, i8* %698
%707 = load i8, i8* %699
%708 = load i8, i8* %700
%709 = insertelement <8 x i8> poison, i8 %701, i64 0
%710 = insertelement <8 x i8> %709, i8 %702, i64 1
%711 = insertelement <8 x i8> %710, i8 %703, i64 2
%712 = insertelement <8 x i8> %711, i8 %704, i64 3
%713 = insertelement <8 x i8> %712, i8 %705, i64 4
%714 = insertelement <8 x i8> %713, i8 %706, i64 5
%715 = insertelement <8 x i8> %714, i8 %707, i64 6
%716 = insertelement <8 x i8> %715, i8 %708, i64 7
%717 = shl <8 x i8> %716, <i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5, i8 5>
%718 = and <8 x i8> %717, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%719 = or <8 x i8> %718, %692
%720 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %719, <8 x i8>* %720
%721 = or i64 %608, 3
%722 = or i64 %608, 11
%723 = or i64 %608, 19
%724 = or i64 %608, 27
%725 = or i64 %608, 35
%726 = or i64 %608, 43
%727 = or i64 %608, 51
%728 = or i64 %608, 59
%729 = and <8 x i8> %719, <i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17, i8 -17>
%730 = getelementptr inbounds i8, i8* %2, i64 %721
%731 = getelementptr inbounds i8, i8* %2, i64 %722
%732 = getelementptr inbounds i8, i8* %2, i64 %723
%733 = getelementptr inbounds i8, i8* %2, i64 %724
%734 = getelementptr inbounds i8, i8* %2, i64 %725
%735 = getelementptr inbounds i8, i8* %2, i64 %726
%736 = getelementptr inbounds i8, i8* %2, i64 %727
%737 = getelementptr inbounds i8, i8* %2, i64 %728
%738 = load i8, i8* %730
%739 = load i8, i8* %731
%740 = load i8, i8* %732
%741 = load i8, i8* %733
%742 = load i8, i8* %734
%743 = load i8, i8* %735
%744 = load i8, i8* %736
%745 = load i8, i8* %737
%746 = insertelement <8 x i8> poison, i8 %738, i64 0
%747 = insertelement <8 x i8> %746, i8 %739, i64 1
%748 = insertelement <8 x i8> %747, i8 %740, i64 2
%749 = insertelement <8 x i8> %748, i8 %741, i64 3
%750 = insertelement <8 x i8> %749, i8 %742, i64 4
%751 = insertelement <8 x i8> %750, i8 %743, i64 5
%752 = insertelement <8 x i8> %751, i8 %744, i64 6
%753 = insertelement <8 x i8> %752, i8 %745, i64 7
%754 = shl <8 x i8> %753, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%755 = and <8 x i8> %754, <i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16>
%756 = or <8 x i8> %755, %729
%757 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %756, <8 x i8>* %757
%758 = or i64 %608, 4
%759 = or i64 %608, 12
%760 = or i64 %608, 20
%761 = or i64 %608, 28
%762 = or i64 %608, 36
%763 = or i64 %608, 44
%764 = or i64 %608, 52
%765 = or i64 %608, 60
%766 = and <8 x i8> %756, <i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9, i8 -9>
%767 = getelementptr inbounds i8, i8* %2, i64 %758
%768 = getelementptr inbounds i8, i8* %2, i64 %759
%769 = getelementptr inbounds i8, i8* %2, i64 %760
%770 = getelementptr inbounds i8, i8* %2, i64 %761
%771 = getelementptr inbounds i8, i8* %2, i64 %762
%772 = getelementptr inbounds i8, i8* %2, i64 %763
%773 = getelementptr inbounds i8, i8* %2, i64 %764
%774 = getelementptr inbounds i8, i8* %2, i64 %765
%775 = load i8, i8* %767
%776 = load i8, i8* %768
%777 = load i8, i8* %769
%778 = load i8, i8* %770
%779 = load i8, i8* %771
%780 = load i8, i8* %772
%781 = load i8, i8* %773
%782 = load i8, i8* %774
%783 = insertelement <8 x i8> poison, i8 %775, i64 0
%784 = insertelement <8 x i8> %783, i8 %776, i64 1
%785 = insertelement <8 x i8> %784, i8 %777, i64 2
%786 = insertelement <8 x i8> %785, i8 %778, i64 3
%787 = insertelement <8 x i8> %786, i8 %779, i64 4
%788 = insertelement <8 x i8> %787, i8 %780, i64 5
%789 = insertelement <8 x i8> %788, i8 %781, i64 6
%790 = insertelement <8 x i8> %789, i8 %782, i64 7
%791 = shl <8 x i8> %790, <i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3, i8 3>
%792 = and <8 x i8> %791, <i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8>
%793 = or <8 x i8> %792, %766
%794 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %793, <8 x i8>* %794
%795 = or i64 %608, 5
%796 = or i64 %608, 13
%797 = or i64 %608, 21
%798 = or i64 %608, 29
%799 = or i64 %608, 37
%800 = or i64 %608, 45
%801 = or i64 %608, 53
%802 = or i64 %608, 61
%803 = and <8 x i8> %793, <i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5, i8 -5>
%804 = getelementptr inbounds i8, i8* %2, i64 %795
%805 = getelementptr inbounds i8, i8* %2, i64 %796
%806 = getelementptr inbounds i8, i8* %2, i64 %797
%807 = getelementptr inbounds i8, i8* %2, i64 %798
%808 = getelementptr inbounds i8, i8* %2, i64 %799
%809 = getelementptr inbounds i8, i8* %2, i64 %800
%810 = getelementptr inbounds i8, i8* %2, i64 %801
%811 = getelementptr inbounds i8, i8* %2, i64 %802
%812 = load i8, i8* %804
%813 = load i8, i8* %805
%814 = load i8, i8* %806
%815 = load i8, i8* %807
%816 = load i8, i8* %808
%817 = load i8, i8* %809
%818 = load i8, i8* %810
%819 = load i8, i8* %811
%820 = insertelement <8 x i8> poison, i8 %812, i64 0
%821 = insertelement <8 x i8> %820, i8 %813, i64 1
%822 = insertelement <8 x i8> %821, i8 %814, i64 2
%823 = insertelement <8 x i8> %822, i8 %815, i64 3
%824 = insertelement <8 x i8> %823, i8 %816, i64 4
%825 = insertelement <8 x i8> %824, i8 %817, i64 5
%826 = insertelement <8 x i8> %825, i8 %818, i64 6
%827 = insertelement <8 x i8> %826, i8 %819, i64 7
%828 = shl <8 x i8> %827, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%829 = and <8 x i8> %828, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%830 = or <8 x i8> %829, %803
%831 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %830, <8 x i8>* %831
%832 = or i64 %608, 6
%833 = or i64 %608, 14
%834 = or i64 %608, 22
%835 = or i64 %608, 30
%836 = or i64 %608, 38
%837 = or i64 %608, 46
%838 = or i64 %608, 54
%839 = or i64 %608, 62
%840 = and <8 x i8> %830, <i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3, i8 -3>
%841 = getelementptr inbounds i8, i8* %2, i64 %832
%842 = getelementptr inbounds i8, i8* %2, i64 %833
%843 = getelementptr inbounds i8, i8* %2, i64 %834
%844 = getelementptr inbounds i8, i8* %2, i64 %835
%845 = getelementptr inbounds i8, i8* %2, i64 %836
%846 = getelementptr inbounds i8, i8* %2, i64 %837
%847 = getelementptr inbounds i8, i8* %2, i64 %838
%848 = getelementptr inbounds i8, i8* %2, i64 %839
%849 = load i8, i8* %841
%850 = load i8, i8* %842
%851 = load i8, i8* %843
%852 = load i8, i8* %844
%853 = load i8, i8* %845
%854 = load i8, i8* %846
%855 = load i8, i8* %847
%856 = load i8, i8* %848
%857 = insertelement <8 x i8> poison, i8 %849, i64 0
%858 = insertelement <8 x i8> %857, i8 %850, i64 1
%859 = insertelement <8 x i8> %858, i8 %851, i64 2
%860 = insertelement <8 x i8> %859, i8 %852, i64 3
%861 = insertelement <8 x i8> %860, i8 %853, i64 4
%862 = insertelement <8 x i8> %861, i8 %854, i64 5
%863 = insertelement <8 x i8> %862, i8 %855, i64 6
%864 = insertelement <8 x i8> %863, i8 %856, i64 7
%865 = shl <8 x i8> %864, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%866 = and <8 x i8> %865, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%867 = or <8 x i8> %866, %840
%868 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %867, <8 x i8>* %868
%869 = or i64 %608, 7
%870 = or i64 %608, 15
%871 = or i64 %608, 23
%872 = or i64 %608, 31
%873 = or i64 %608, 39
%874 = or i64 %608, 47
%875 = or i64 %608, 55
%876 = or i64 %608, 63
%877 = and <8 x i8> %867, <i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2, i8 -2>
%878 = getelementptr inbounds i8, i8* %2, i64 %869
%879 = getelementptr inbounds i8, i8* %2, i64 %870
%880 = getelementptr inbounds i8, i8* %2, i64 %871
%881 = getelementptr inbounds i8, i8* %2, i64 %872
%882 = getelementptr inbounds i8, i8* %2, i64 %873
%883 = getelementptr inbounds i8, i8* %2, i64 %874
%884 = getelementptr inbounds i8, i8* %2, i64 %875
%885 = getelementptr inbounds i8, i8* %2, i64 %876
%886 = load i8, i8* %878
%887 = load i8, i8* %879
%888 = load i8, i8* %880
%889 = load i8, i8* %881
%890 = load i8, i8* %882
%891 = load i8, i8* %883
%892 = load i8, i8* %884
%893 = load i8, i8* %885
%894 = insertelement <8 x i8> poison, i8 %886, i64 0
%895 = insertelement <8 x i8> %894, i8 %887, i64 1
%896 = insertelement <8 x i8> %895, i8 %888, i64 2
%897 = insertelement <8 x i8> %896, i8 %889, i64 3
%898 = insertelement <8 x i8> %897, i8 %890, i64 4
%899 = insertelement <8 x i8> %898, i8 %891, i64 5
%900 = insertelement <8 x i8> %899, i8 %892, i64 6
%901 = insertelement <8 x i8> %900, i8 %893, i64 7
%902 = and <8 x i8> %901, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%903 = or <8 x i8> %902, %877
%904 = bitcast i8* %616 to <8 x i8>*
store <8 x i8> %903, <8 x i8>* %904
%905 = add nuw i64 %607, 8
%906 = icmp eq i64 %905, %604
br i1 %906, label %907, label %606
907: ; preds = %606
%908 = icmp eq i64 %604, %16
br i1 %908, label %975, label %909
909: ; preds = %28, %18, %15, %598, %907
%910 = phi i64 [ 0, %15 ], [ 0, %28 ], [ 0, %18 ], [ %38, %598 ], [ %604, %907 ]
%911 = phi i64 [ 0, %15 ], [ 0, %28 ], [ 0, %18 ], [ %599, %598 ], [ %605, %907 ]
br label %912
912: ; preds = %909, %912
%913 = phi i64 [ %973, %912 ], [ %910, %909 ]
%914 = phi i64 [ %972, %912 ], [ %911, %909 ]
%915 = getelementptr inbounds i8, i8* %0, i64 %913
%916 = shl i64 %914, 32
%917 = ashr exact i64 %916, 32
%918 = load i8, i8* %915
%919 = and i8 %918, 127
%920 = getelementptr inbounds i8, i8* %2, i64 %917
%921 = load i8, i8* %920
%922 = shl i8 %921, 7
%923 = or i8 %922, %919
store i8 %923, i8* %915
%924 = add nsw i64 %917, 1
%925 = and i8 %923, -65
%926 = getelementptr inbounds i8, i8* %2, i64 %924
%927 = load i8, i8* %926
%928 = shl i8 %927, 6
%929 = and i8 %928, 64
%930 = or i8 %929, %925
store i8 %930, i8* %915
%931 = add nsw i64 %917, 2
%932 = and i8 %930, -33
%933 = getelementptr inbounds i8, i8* %2, i64 %931
%934 = load i8, i8* %933
%935 = shl i8 %934, 5
%936 = and i8 %935, 32
%937 = or i8 %936, %932
store i8 %937, i8* %915
%938 = add nsw i64 %917, 3
%939 = and i8 %937, -17
%940 = getelementptr inbounds i8, i8* %2, i64 %938
%941 = load i8, i8* %940
%942 = shl i8 %941, 4
%943 = and i8 %942, 16
%944 = or i8 %943, %939
store i8 %944, i8* %915
%945 = add nsw i64 %917, 4
%946 = and i8 %944, -9
%947 = getelementptr inbounds i8, i8* %2, i64 %945
%948 = load i8, i8* %947
%949 = shl i8 %948, 3
%950 = and i8 %949, 8
%951 = or i8 %950, %946
store i8 %951, i8* %915
%952 = add nsw i64 %917, 5
%953 = and i8 %951, -5
%954 = getelementptr inbounds i8, i8* %2, i64 %952
%955 = load i8, i8* %954
%956 = shl i8 %955, 2
%957 = and i8 %956, 4
%958 = or i8 %957, %953
store i8 %958, i8* %915
%959 = add nsw i64 %917, 6
%960 = and i8 %958, -3
%961 = getelementptr inbounds i8, i8* %2, i64 %959
%962 = load i8, i8* %961
%963 = shl i8 %962, 1
%964 = and i8 %963, 2
%965 = or i8 %964, %960
store i8 %965, i8* %915
%966 = add nsw i64 %917, 7
%967 = and i8 %965, -2
%968 = getelementptr inbounds i8, i8* %2, i64 %966
%969 = load i8, i8* %968
%970 = and i8 %969, 1
%971 = or i8 %970, %967
store i8 %971, i8* %915
%972 = add nsw i64 %917, 8
%973 = add nuw nsw i64 %913, 1
%974 = icmp eq i64 %973, %16
br i1 %974, label %975, label %912
975: ; preds = %912, %596, %907, %12, %5
%976 = phi i32 [ -1, %5 ], [ 0, %12 ], [ 0, %907 ], [ 0, %596 ], [ 0, %912 ]
ret i32 %976
}