#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, unsigned int);
void scan_program(char *cdata, int length) {
  unsigned i, j;
  unsigned char *data = cdata;
  unsigned total = 0;
  for (i = 0; i < length; i++) {
    data[i] = i % 256;
  }
  for (j = 0; j < 10; j++) {
    for (i = 0; i < length; i++) {
      total += data[i];
    }
  }
  printf("scan result is %d\n", total);
}


x86 assembly (clang, -O0):
<scan_program>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1163 <scan_program+0x53>
mov    -0x10(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1135 <scan_program+0x25>
movl   $0x0,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jae    11b9 <scan_program+0xa9>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11a6 <scan_program+0x96>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    117b <scan_program+0x6b>
jmp    11ab <scan_program+0x9b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116a <scan_program+0x5a>
mov    -0x24(%rbp),%esi
lea    0xe3d(%rip),%rdi
call   1030 <printf@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scan_program>:
test   %esi,%esi
je     127e <scan_program+0x16e>
mov    %esi,%r8d
cmp    $0x10,%esi
jae    1127 <scan_program+0x17>
xor    %eax,%eax
jmp    1260 <scan_program+0x150>
mov    %r8d,%eax
and    $0xfffffff0,%eax
lea    -0x10(%rax),%rcx
mov    %rcx,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x7,%r9d
cmp    $0x70,%rcx
jae    1158 <scan_program+0x48>
movdqa 0xeaf(%rip),%xmm2
xor    %ecx,%ecx
jmp    1227 <scan_program+0x117>
and    $0xfffffffffffffff8,%rdx
movdqa 0xe9c(%rip),%xmm2
xor    %ecx,%ecx
movdqa 0xea1(%rip),%xmm8
movdqa 0xea8(%rip),%xmm9
movdqa 0xeb0(%rip),%xmm3
movdqa 0xeb8(%rip),%xmm4
movdqa 0xec0(%rip),%xmm5
movdqa 0xec8(%rip),%xmm6
movdqa 0xed0(%rip),%xmm7
movdqa 0xed8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqu %xmm2,(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm8,%xmm0
movdqu %xmm0,0x10(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm9,%xmm0
movdqu %xmm0,0x20(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm3,%xmm0
movdqu %xmm0,0x30(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm4,%xmm0
movdqu %xmm0,0x40(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm5,%xmm0
movdqu %xmm0,0x50(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm6,%xmm0
movdqu %xmm0,0x60(%rdi,%rcx,1)
movdqa %xmm2,%xmm0
paddb  %xmm7,%xmm0
movdqu %xmm0,0x70(%rdi,%rcx,1)
sub    $0xffffffffffffff80,%rcx
pxor   %xmm1,%xmm2
add    $0xfffffffffffffff8,%rdx
jne    11b0 <scan_program+0xa0>
test   %r9,%r9
je     1252 <scan_program+0x142>
add    %rdi,%rcx
shl    $0x4,%r9
xor    %edx,%edx
movdqa 0xdd3(%rip),%xmm1
nopl   (%rax)
movdqu %xmm2,(%rcx,%rdx,1)
paddb  %xmm1,%xmm2
add    $0x10,%rdx
cmp    %rdx,%r9
jne    1240 <scan_program+0x130>
cmp    %r8,%rax
je     126c <scan_program+0x15c>
nopw   0x0(%rax,%rax,1)
mov    %al,(%rdi,%rax,1)
add    $0x1,%rax
cmp    %rax,%r8
jne    1260 <scan_program+0x150>
test   %esi,%esi
je     127e <scan_program+0x16e>
cmp    $0x8,%esi
jae    128e <scan_program+0x17e>
xor    %edx,%edx
xor    %eax,%eax
jmp    1370 <scan_program+0x260>
xor    %eax,%eax
lea    0xe09(%rip),%rdi
mov    %eax,%esi
jmp    1030 <printf@plt>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1593 <scan_program+0x483>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    12d0 <scan_program+0x1c0>
test   $0x1,%r9b
je     134e <scan_program+0x23e>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     137f <scan_program+0x26f>
nopl   (%rax)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1370 <scan_program+0x260>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    1393 <scan_program+0x283>
xor    %edx,%edx
jmp    1470 <scan_program+0x360>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     16a3 <scan_program+0x593>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    13d0 <scan_program+0x2c0>
test   $0x1,%r9b
je     144e <scan_program+0x33e>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     147f <scan_program+0x36f>
nopl   (%rax)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1470 <scan_program+0x360>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    1493 <scan_program+0x383>
xor    %edx,%edx
jmp    1570 <scan_program+0x460>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1743 <scan_program+0x633>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    14d0 <scan_program+0x3c0>
test   $0x1,%r9b
je     154e <scan_program+0x43e>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     157f <scan_program+0x46f>
nopl   (%rax)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1570 <scan_program+0x460>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    15ac <scan_program+0x49c>
xor    %edx,%edx
jmp    1680 <scan_program+0x570>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    1327 <scan_program+0x217>
jmp    134e <scan_program+0x23e>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1758 <scan_program+0x648>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nop
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    15e0 <scan_program+0x4d0>
test   $0x1,%r9b
je     165e <scan_program+0x54e>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     168f <scan_program+0x57f>
nopl   (%rax)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1680 <scan_program+0x570>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    16b8 <scan_program+0x5a8>
xor    %edx,%edx
jmp    17c0 <scan_program+0x6b0>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
jne    1427 <scan_program+0x317>
jmp    144e <scan_program+0x33e>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     176d <scan_program+0x65d>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    16f0 <scan_program+0x5e0>
jmp    1773 <scan_program+0x663>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
jne    1527 <scan_program+0x417>
jmp    154e <scan_program+0x43e>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
jne    1637 <scan_program+0x527>
jmp    165e <scan_program+0x54e>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
je     17a0 <scan_program+0x690>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     17cf <scan_program+0x6bf>
nop
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    17c0 <scan_program+0x6b0>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    17e3 <scan_program+0x6d3>
xor    %edx,%edx
jmp    18d0 <scan_program+0x7c0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1873 <scan_program+0x763>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1820 <scan_program+0x710>
jmp    1879 <scan_program+0x769>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
je     18a6 <scan_program+0x796>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     18df <scan_program+0x7cf>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    18d0 <scan_program+0x7c0>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    18f3 <scan_program+0x7e3>
xor    %edx,%edx
jmp    19e0 <scan_program+0x8d0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1983 <scan_program+0x873>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1930 <scan_program+0x820>
jmp    1989 <scan_program+0x879>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
je     19b6 <scan_program+0x8a6>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     19ef <scan_program+0x8df>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    19e0 <scan_program+0x8d0>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    1a03 <scan_program+0x8f3>
xor    %edx,%edx
jmp    1ae0 <scan_program+0x9d0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1a85 <scan_program+0x975>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1a32 <scan_program+0x922>
jmp    1a8b <scan_program+0x97b>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
je     1ab8 <scan_program+0x9a8>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     1aef <scan_program+0x9df>
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1ae0 <scan_program+0x9d0>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    1b03 <scan_program+0x9f3>
xor    %edx,%edx
jmp    1be0 <scan_program+0xad0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1b85 <scan_program+0xa75>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1b32 <scan_program+0xa22>
jmp    1b8b <scan_program+0xa7b>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%r9b
je     1bb8 <scan_program+0xaa8>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     1bef <scan_program+0xadf>
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1be0 <scan_program+0xad0>
test   %esi,%esi
je     1280 <scan_program+0x170>
cmp    $0x8,%esi
jae    1c03 <scan_program+0xaf3>
xor    %edx,%edx
jmp    1cd9 <scan_program+0xbc9>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     1c85 <scan_program+0xb75>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
movd   (%rdi,%rcx,1),%xmm3
movd   0x4(%rdi,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rcx,1),%xmm0
movd   0xc(%rdi,%rcx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1c32 <scan_program+0xb22>
jmp    1c8b <scan_program+0xb7b>
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
test   $0x1,%al
je     1cb6 <scan_program+0xba6>
movd   (%rdi,%rcx,1),%xmm2
movd   0x4(%rdi,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rdx
je     1280 <scan_program+0x170>
movzbl (%rdi,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1cd9 <scan_program+0xbc9>
jmp    1280 <scan_program+0x170>

LLVM IR (-O0):
@.str = [19 x i8] c"scan result is %d\0A\00"
define void @scan_program(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
%9 = load i8*, i8** %3
store i8* %9, i8** %7
store i32 0, i32* %8
store i32 0, i32* %5
br label %10
10: ; preds = %22, %2
%11 = load i32, i32* %5
%12 = load i32, i32* %4
%13 = icmp ult i32 %11, %12
br i1 %13, label %14, label %25
14: ; preds = %10
%15 = load i32, i32* %5
%16 = urem i32 %15, 256
%17 = trunc i32 %16 to i8
%18 = load i8*, i8** %7
%19 = load i32, i32* %5
%20 = zext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
store i8 %17, i8* %21
br label %22
22: ; preds = %14
%23 = load i32, i32* %5
%24 = add i32 %23, 1
store i32 %24, i32* %5
br label %10
25: ; preds = %10
store i32 0, i32* %6
br label %26
26: ; preds = %47, %25
%27 = load i32, i32* %6
%28 = icmp ult i32 %27, 10
br i1 %28, label %29, label %50
29: ; preds = %26
store i32 0, i32* %5
br label %30
30: ; preds = %43, %29
%31 = load i32, i32* %5
%32 = load i32, i32* %4
%33 = icmp ult i32 %31, %32
br i1 %33, label %34, label %46
34: ; preds = %30
%35 = load i8*, i8** %7
%36 = load i32, i32* %5
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = load i32, i32* %8
%42 = add i32 %41, %40
store i32 %42, i32* %8
br label %43
43: ; preds = %34
%44 = load i32, i32* %5
%45 = add i32 %44, 1
store i32 %45, i32* %5
br label %30
46: ; preds = %30
br label %47
47: ; preds = %46
%48 = load i32, i32* %6
%49 = add i32 %48, 1
store i32 %49, i32* %6
br label %26
50: ; preds = %26
%51 = load i32, i32* %8
%52 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i32 %51)
ret void
}

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