#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 */
typedef int uint8_t;

/* Variables and functions */
void get_dc_pred(uint8_t *rec, int ypos, int xpos, int stride, int size,
                 uint8_t *pblock) {
  int i, j, dc = 128, sum;
  if (ypos > 0 && xpos > 0) {
    sum = 0;
    for (j = 0; j < size; j++)
      sum += rec[(ypos - 1) * stride + xpos + j];
    for (i = 0; i < size; i++)
      sum += rec[(ypos + i) * stride + xpos - 1];
    dc = (sum + size) / (2 * size);
  } else if (ypos > 0 && xpos == 0) {
    sum = 0;
    for (j = 0; j < size; j++)
      sum += rec[(ypos - 1) * stride + xpos + j];
    dc = (sum + size / 2) / size;
  } else if (ypos == 0 && xpos > 0) {
    sum = 0;
    for (i = 0; i < size; i++)
      sum += rec[(ypos + i) * stride + xpos - 1];
    dc = (sum + size / 2) / size;
  } else if (ypos == 0 && xpos == 0) {
    dc = 128;
  }
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      pblock[i * size + j] = dc;
    }
  }
}


x86 assembly (clang, -O0):
<get_dc_pred>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movl   $0x80,-0x2c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jle    11d4 <get_dc_pred+0xd4>
cmpl   $0x0,-0x10(%rbp)
jle    11d4 <get_dc_pred+0xd4>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    117c <get_dc_pred+0x7c>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1142 <get_dc_pred+0x42>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11bd <get_dc_pred+0xbd>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1183 <get_dc_pred+0x83>
mov    -0x30(%rbp),%eax
add    -0x18(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
jmp    12fe <get_dc_pred+0x1fe>
cmpl   $0x0,-0xc(%rbp)
jle    1254 <get_dc_pred+0x154>
cmpl   $0x0,-0x10(%rbp)
jne    1254 <get_dc_pred+0x154>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1230 <get_dc_pred+0x130>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11f6 <get_dc_pred+0xf6>
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
add    %ecx,%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,-0x2c(%rbp)
jmp    12f9 <get_dc_pred+0x1f9>
cmpl   $0x0,-0xc(%rbp)
jne    12d4 <get_dc_pred+0x1d4>
cmpl   $0x0,-0x10(%rbp)
jle    12d4 <get_dc_pred+0x1d4>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12b0 <get_dc_pred+0x1b0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1276 <get_dc_pred+0x176>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x38(%rbp),%eax
add    %ecx,%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,-0x2c(%rbp)
jmp    12f4 <get_dc_pred+0x1f4>
cmpl   $0x0,-0xc(%rbp)
jne    12ef <get_dc_pred+0x1ef>
cmpl   $0x0,-0x10(%rbp)
jne    12ef <get_dc_pred+0x1ef>
movl   $0x80,-0x2c(%rbp)
jmp    12f4 <get_dc_pred+0x1f4>
jmp    12f9 <get_dc_pred+0x1f9>
jmp    12fe <get_dc_pred+0x1fe>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    135c <get_dc_pred+0x25c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1349 <get_dc_pred+0x249>
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1318 <get_dc_pred+0x218>
jmp    134e <get_dc_pred+0x24e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1305 <get_dc_pred+0x205>
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_dc_pred>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %esi,%esi
jle    113c <get_dc_pred+0x3c>
test   %edx,%edx
jle    113c <get_dc_pred+0x3c>
test   %r8d,%r8d
jle    1261 <get_dc_pred+0x161>
lea    -0x1(%rsi),%eax
imul   %ecx,%eax
add    %edx,%eax
movslq %eax,%r11
mov    %r8d,%r10d
cmp    $0x8,%r8d
jae    1268 <get_dc_pred+0x168>
xor    %ebx,%ebx
xor    %eax,%eax
jmp    139b <get_dc_pred+0x29b>
test   %esi,%esi
jle    116c <get_dc_pred+0x6c>
test   %edx,%edx
jne    116c <get_dc_pred+0x6c>
test   %r8d,%r8d
jle    1299 <get_dc_pred+0x199>
add    $0xffffffff,%esi
imul   %ecx,%esi
movslq %esi,%r10
mov    %r8d,%eax
cmp    $0x8,%r8d
jae    12a0 <get_dc_pred+0x1a0>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    16fb <get_dc_pred+0x5fb>
mov    $0x80,%eax
test   %esi,%esi
jne    154e <get_dc_pred+0x44e>
test   %edx,%edx
jle    154e <get_dc_pred+0x44e>
test   %r8d,%r8d
jle    161b <get_dc_pred+0x51b>
mov    %r8d,%r14d
xor    %r11d,%r11d
cmp    $0x8,%r8d
jb     155c <get_dc_pred+0x45c>
cmp    $0x1,%ecx
jne    155c <get_dc_pred+0x45c>
lea    -0x1(%rdx),%r10d
lea    -0x1(%r14),%rax
lea    (%rdx,%rax,1),%esi
add    $0xffffffff,%esi
cmp    %r10d,%esi
jl     155c <get_dc_pred+0x45c>
shr    $0x20,%rax
mov    $0x0,%ebx
jne    155e <get_dc_pred+0x45e>
mov    %r14d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rax
mov    %rax,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rax,%rax
je     1863 <get_dc_pred+0x763>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
and    %r15,%rax
lea    0x0(,%rcx,8),%r12d
mov    %ecx,%r13d
shl    $0x4,%r13d
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
mov    %r10d,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movslq %esi,%rsi
movdqu (%rdi,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rsi,4),%xmm3
paddd  %xmm1,%xmm3
lea    (%r12,%rsi,1),%ebx
movslq %ebx,%rbx
movdqu (%rdi,%rbx,4),%xmm0
paddd  %xmm2,%xmm0
movdqu 0x10(%rdi,%rbx,4),%xmm1
paddd  %xmm3,%xmm1
add    %r13d,%esi
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rax
jne    1220 <get_dc_pred+0x120>
jmp    186d <get_dc_pred+0x76d>
xor    %eax,%eax
jmp    1544 <get_dc_pred+0x444>
mov    %r10d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rax
mov    %rax,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15d,%r14d
and    $0x3,%r14d
cmp    $0x18,%rax
jae    12d2 <get_dc_pred+0x1d2>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    1349 <get_dc_pred+0x249>
xor    %edx,%edx
jmp    170c <get_dc_pred+0x60c>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdx
jae    162f <get_dc_pred+0x52f>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    16a9 <get_dc_pred+0x5a9>
and    $0xfffffffffffffffc,%r15
lea    (%rdi,%r11,4),%rax
add    $0x70,%rax
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x70(%rax,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rax,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rax,%rbp,4),%xmm1
movdqu -0x40(%rax,%rbp,4),%xmm3
movdqu -0x30(%rax,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rax,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rax,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rax,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r15
jne    12f0 <get_dc_pred+0x1f0>
test   %r14,%r14
je     137c <get_dc_pred+0x27c>
add    %r11,%rbp
lea    (%rdi,%rbp,4),%rax
add    $0x10,%rax
shl    $0x5,%r14
xor    %ebp,%ebp
nop
movdqu -0x10(%rax,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rax,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1360 <get_dc_pred+0x260>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r10,%rbx
je     13ad <get_dc_pred+0x2ad>
lea    (%rdi,%r11,4),%rbp
nop
add    0x0(%rbp,%rbx,4),%eax
add    $0x1,%rbx
cmp    %rbx,%r10
jne    13a0 <get_dc_pred+0x2a0>
test   %r8d,%r8d
jle    1544 <get_dc_pred+0x444>
lea    -0x1(%rdx),%r14d
xor    %r11d,%r11d
cmp    $0x8,%r8d
jae    142b <get_dc_pred+0x32b>
mov    %r11,%rbx
not    %rbx
test   $0x1,%r10b
je     13e3 <get_dc_pred+0x2e3>
lea    (%r11,%rsi,1),%ebp
imul   %ecx,%ebp
add    %ebp,%r14d
movslq %r14d,%rbp
add    (%rdi,%rbp,4),%eax
or     $0x1,%r11
add    %r10,%rbx
je     1544 <get_dc_pred+0x444>
mov    %esi,%ebp
add    %r11d,%ebp
add    %r11d,%esi
add    $0x1,%esi
imul   %ecx,%esi
add    %edx,%esi
add    $0xffffffff,%esi
lea    (%rcx,%rcx,1),%ebx
sub    %r11,%r10
imul   %ecx,%ebp
lea    (%rdx,%rbp,1),%ecx
add    $0xffffffff,%ecx
xchg   %ax,%ax
movslq %ecx,%rcx
add    (%rdi,%rcx,4),%eax
movslq %esi,%rsi
add    (%rdi,%rsi,4),%eax
add    %ebx,%esi
add    %ebx,%ecx
add    $0xfffffffffffffffe,%r10
jne    1410 <get_dc_pred+0x310>
jmp    1544 <get_dc_pred+0x444>
cmp    $0x1,%ecx
jne    13c3 <get_dc_pred+0x2c3>
lea    -0x1(%r10),%rbx
lea    (%rdx,%rsi,1),%r15d
lea    (%rdx,%rsi,1),%r12d
add    $0xffffffff,%r12d
lea    (%rbx,%r15,1),%ebp
add    $0xffffffff,%ebp
cmp    %r12d,%ebp
jl     13c3 <get_dc_pred+0x2c3>
shr    $0x20,%rbx
jne    13c3 <get_dc_pred+0x2c3>
mov    %r10d,%r11d
and    $0xfffffff8,%r11d
movd   %eax,%xmm0
lea    -0x8(%r11),%rax
mov    %rax,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rax,%rax
je     184d <get_dc_pred+0x74d>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %r15,%rbx
lea    0x8(%rsi),%eax
imul   %ecx,%eax
add    %edx,%eax
add    $0xffffffff,%eax
mov    %ecx,%r12d
shl    $0x4,%r12d
mov    %ecx,%ebp
imul   %esi,%ebp
add    %edx,%ebp
add    $0xffffffff,%ebp
pxor   %xmm1,%xmm1
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
movdqu (%rdi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rbp,4),%xmm3
paddd  %xmm1,%xmm3
cltq
movdqu (%rdi,%rax,4),%xmm0
paddd  %xmm2,%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
paddd  %xmm3,%xmm1
add    %r12d,%eax
add    $0x10,%r13d
add    %r12d,%ebp
add    $0xfffffffffffffffe,%rbx
jne    14c0 <get_dc_pred+0x3c0>
test   $0x1,%r15b
je     1521 <get_dc_pred+0x421>
add    %esi,%r13d
imul   %ecx,%r13d
add    %r14d,%r13d
movslq %r13d,%rax
movdqu (%rdi,%rax,4),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r10,%r11
jne    13c3 <get_dc_pred+0x2c3>
add    %r8d,%eax
lea    (%r8,%r8,1),%ecx
cltd
idiv   %ecx
test   %r8d,%r8d
jg     1726 <get_dc_pred+0x626>
jmp    1842 <get_dc_pred+0x742>
xor    %ebx,%ebx
mov    %r11,%r10
not    %r10
add    %r14,%r10
mov    %r14,%rsi
and    $0x3,%rsi
je     15a4 <get_dc_pred+0x4a4>
mov    %ecx,%eax
imul   %r11d,%eax
lea    (%rdx,%rax,1),%ebp
add    $0xffffffff,%ebp
neg    %rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
add    (%rdi,%rbp,4),%ebx
add    $0xffffffffffffffff,%rax
add    %ecx,%ebp
cmp    %rax,%rsi
jne    1590 <get_dc_pred+0x490>
sub    %rax,%r11
cmp    $0x3,%r10
jb     161d <get_dc_pred+0x51d>
lea    0x3(%r11),%eax
imul   %ecx,%eax
lea    (%rdx,%rax,1),%ebp
add    $0xffffffff,%ebp
lea    0x0(,%rcx,4),%r10d
lea    0x2(%r11),%eax
imul   %ecx,%eax
add    %edx,%eax
add    $0xffffffff,%eax
lea    0x1(%r11),%esi
imul   %ecx,%esi
add    %edx,%esi
add    $0xffffffff,%esi
sub    %r11,%r14
imul   %r11d,%ecx
add    %edx,%ecx
add    $0xffffffff,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rcx
add    (%rdi,%rcx,4),%ebx
movslq %esi,%rsi
add    (%rdi,%rsi,4),%ebx
cltq
add    (%rdi,%rax,4),%ebx
movslq %ebp,%rbp
add    (%rdi,%rbp,4),%ebx
add    %r10d,%ebp
add    %r10d,%eax
add    %r10d,%esi
add    %r10d,%ecx
add    $0xfffffffffffffffc,%r14
jne    15f0 <get_dc_pred+0x4f0>
jmp    161d <get_dc_pred+0x51d>
xor    %ebx,%ebx
mov    %r8d,%eax
shr    $0x1f,%eax
add    %r8d,%eax
sar    %eax
add    %ebx,%eax
jmp    1719 <get_dc_pred+0x619>
and    $0xfffffffffffffffc,%rsi
lea    (%rdi,%r10,4),%rdx
add    $0x70,%rdx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x70(%rdx,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rdx,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rdx,%rbp,4),%xmm1
movdqu -0x40(%rdx,%rbp,4),%xmm3
movdqu -0x30(%rdx,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rdx,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rdx,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rdx,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1650 <get_dc_pred+0x550>
test   %rbx,%rbx
je     16dc <get_dc_pred+0x5dc>
add    %r10,%rbp
lea    (%rdi,%rbp,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %esi,%esi
nop
movdqu -0x10(%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdx,%rsi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    16c0 <get_dc_pred+0x5c0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     170c <get_dc_pred+0x60c>
lea    (%rdi,%r10,4),%rsi
nop
add    (%rsi,%rcx,4),%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1700 <get_dc_pred+0x600>
mov    %r8d,%eax
shr    $0x1f,%eax
add    %r8d,%eax
sar    %eax
add    %edx,%eax
cltd
idiv   %r8d
test   %r8d,%r8d
jle    1842 <get_dc_pred+0x742>
mov    %r8d,%ecx
mov    %ecx,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%r11
mov    %r11,%r10
shr    $0x3,%r10
add    $0x1,%r10
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %r10d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r10
lea    0x70(%r9),%rbx
lea    0x0(,%rcx,4),%r12
lea    0x10(%r9),%r13
mov    %r14,%rdx
shl    $0x5,%rdx
xor    %esi,%esi
jmp    1786 <get_dc_pred+0x686>
xchg   %ax,%ax
add    $0x1,%rsi
add    %r12,%rbx
add    %r12,%r13
add    %r12,%r9
cmp    %rcx,%rsi
je     1842 <get_dc_pred+0x742>
cmp    $0x8,%r8d
jae    17a0 <get_dc_pred+0x6a0>
xor    %edi,%edi
jmp    1830 <get_dc_pred+0x730>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x18,%r11
jae    17b0 <get_dc_pred+0x6b0>
xor    %ebp,%ebp
jmp    17f9 <get_dc_pred+0x6f9>
nopw   0x0(%rax,%rax,1)
mov    %r10,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,-0x70(%rbx,%rbp,4)
movdqu %xmm0,-0x60(%rbx,%rbp,4)
movdqu %xmm0,-0x50(%rbx,%rbp,4)
movdqu %xmm0,-0x40(%rbx,%rbp,4)
movdqu %xmm0,-0x30(%rbx,%rbp,4)
movdqu %xmm0,-0x20(%rbx,%rbp,4)
movdqu %xmm0,-0x10(%rbx,%rbp,4)
movdqu %xmm0,(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    17c0 <get_dc_pred+0x6c0>
test   %r14,%r14
je     1824 <get_dc_pred+0x724>
lea    0x0(,%rbp,4),%rdi
add    %r13,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm0,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1810 <get_dc_pred+0x710>
mov    %r15,%rdi
cmp    %rcx,%r15
je     1770 <get_dc_pred+0x670>
mov    %eax,(%r9,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1830 <get_dc_pred+0x730>
jmp    1770 <get_dc_pred+0x670>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm1,%xmm1
xor    %r13d,%r13d
test   $0x1,%r15b
jne    1501 <get_dc_pred+0x401>
jmp    1521 <get_dc_pred+0x421>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
test   $0x1,%r15b
je     188f <get_dc_pred+0x78f>
imul   %ecx,%ebp
add    %ebp,%r10d
movslq %r10d,%rax
movdqu (%rdi,%rax,4),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %r14,%r11
jne    155e <get_dc_pred+0x45e>
jmp    161d <get_dc_pred+0x51d>

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

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