#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;
typedef int uint16_t;

/* Variables and functions */
void get_upupright_pred(uint8_t *rec, int ypos, int xpos, int stride, int size,
                        int width, uint8_t *pblock, int upright_available) {
  int i, j, diag;
  uint16_t ver[2 * 64];
  uint8_t verF[2 * 64];
  if (ypos > 0) {
    for (j = 0; j < size; j++) {
      ver[j] = rec[(ypos - 1) * stride + xpos + j];
    }
    if (upright_available) {
      for (j = size; j < 2 * size; j++) {
        ver[j] = rec[(ypos - 1) * stride + xpos + j];
      }
    } else {
      for (j = size; j < 2 * size; j++) {
        ver[j] = rec[(ypos - 1) * stride + xpos + size - 1];
      }
    }
  } else {
    for (j = 0; j < 2 * size; j++) {
      ver[j] = 128;
    }
  }
  verF[0] = (uint8_t)((ver[0] + 2 * ver[0] + ver[1] + 2) >> 2);
  for (j = 1; j < 2 * size - 1; j++) {
    verF[j] = (uint8_t)((ver[j - 1] + 2 * ver[j] + ver[j + 1] + 2) >> 2);
  }
  verF[2 * size - 1] = (uint8_t)((ver[2 * size - 2] + 2 * ver[2 * size - 1] +
                                  ver[2 * size - 1] + 2) >>
                                 2);
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      diag = i + 2 * j;
      if (diag & 1) {
        pblock[i * size + j] = verF[(diag + 1) / 2];
      } else {
        pblock[i * size + j] = (verF[diag / 2] + verF[diag / 2 + 1]) >> 1;
      }
    }
  }
}


x86 assembly (clang, -O0):
<get_upupright_pred>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3c0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jle    1227 <get_upupright_pred+0x127>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1177 <get_upupright_pred+0x77>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1138 <get_upupright_pred+0x38>
cmpl   $0x0,0x18(%rbp)
je     11d0 <get_upupright_pred+0xd0>
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    11cb <get_upupright_pred+0xcb>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1187 <get_upupright_pred+0x87>
jmp    1222 <get_upupright_pred+0x122>
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    121d <get_upupright_pred+0x11d>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11d6 <get_upupright_pred+0xd6>
jmp    1222 <get_upupright_pred+0x122>
jmp    1261 <get_upupright_pred+0x161>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    125c <get_upupright_pred+0x15c>
movslq -0x24(%rbp),%rax
movl   $0x80,-0x230(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    122e <get_upupright_pred+0x12e>
jmp    1261 <get_upupright_pred+0x161>
mov    -0x230(%rbp),%eax
mov    -0x230(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    -0x22c(%rbp),%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x430(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12ec <get_upupright_pred+0x1ec>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x230(%rbp,%rax,4),%ecx
movslq -0x24(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
add    -0x230(%rbp,%rax,4),%ecx
add    $0x2,%ecx
sar    $0x2,%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    128b <get_upupright_pred+0x18b>
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x2,%eax
cltq
mov    -0x230(%rbp,%rax,4),%ecx
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cltq
mov    -0x230(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cltq
add    -0x230(%rbp,%rax,4),%ecx
add    $0x2,%ecx
sar    $0x2,%ecx
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x430(%rbp,%rax,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1426 <get_upupright_pred+0x326>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1413 <get_upupright_pred+0x313>
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     13b2 <get_upupright_pred+0x2b2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
mov    -0x430(%rbp,%rax,4),%edx
mov    0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1400 <get_upupright_pred+0x300>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x434(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x434(%rbp),%edx
add    $0x1,%eax
cltq
add    -0x430(%rbp,%rax,4),%edx
sar    $0x1,%edx
mov    0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1405 <get_upupright_pred+0x305>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1359 <get_upupright_pred+0x259>
jmp    1418 <get_upupright_pred+0x318>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1346 <get_upupright_pred+0x246>
add    $0x3c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_upupright_pred>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x380,%rsp
mov    %r8d,%r11d
test   %esi,%esi
jle    1140 <get_upupright_pred+0x40>
mov    0x3b8(%rsp),%r10d
test   %r8d,%r8d
jle    12a1 <get_upupright_pred+0x1a1>
lea    -0x1(%rsi),%eax
imul   %ecx,%eax
add    %edx,%eax
movslq %eax,%r9
cmp    $0x8,%r8d
jae    1166 <get_upupright_pred+0x66>
xor    %eax,%eax
jmp    1286 <get_upupright_pred+0x186>
lea    (%r8,%r8,1),%r9d
test   %r8d,%r8d
jle    159d <get_upupright_pred+0x49d>
cmp    $0x2,%r9d
mov    $0x1,%ecx
cmovge %r9d,%ecx
cmp    $0x8,%ecx
jae    118f <get_upupright_pred+0x8f>
xor    %eax,%eax
jmp    14e0 <get_upupright_pred+0x3e0>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbx
mov    %rbx,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15d,%r14d
and    $0x3,%r14d
cmp    $0x18,%rbx
jae    11bb <get_upupright_pred+0xbb>
xor    %ebx,%ebx
jmp    1233 <get_upupright_pred+0x133>
mov    %ecx,%eax
and    $0x7ffffff8,%eax
lea    -0x8(%rax),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    140f <get_upupright_pred+0x30f>
xor    %edi,%edi
jmp    1499 <get_upupright_pred+0x399>
and    $0xfffffffffffffffc,%r15
lea    (%rdi,%r9,4),%r12
add    $0x70,%r12
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x70(%r12,%rbx,4),%xmm0
movups -0x60(%r12,%rbx,4),%xmm1
movaps %xmm0,-0x80(%rsp,%rbx,4)
movaps %xmm1,-0x70(%rsp,%rbx,4)
movups -0x50(%r12,%rbx,4),%xmm0
movups -0x40(%r12,%rbx,4),%xmm1
movaps %xmm0,-0x60(%rsp,%rbx,4)
movaps %xmm1,-0x50(%rsp,%rbx,4)
movups -0x30(%r12,%rbx,4),%xmm0
movups -0x20(%r12,%rbx,4),%xmm1
movaps %xmm0,-0x40(%rsp,%rbx,4)
movaps %xmm1,-0x30(%rsp,%rbx,4)
movdqu -0x10(%r12,%rbx,4),%xmm0
movups (%r12,%rbx,4),%xmm1
movdqa %xmm0,-0x20(%rsp,%rbx,4)
movaps %xmm1,-0x10(%rsp,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r15
jne    11d0 <get_upupright_pred+0xd0>
test   %r14,%r14
je     1281 <get_upupright_pred+0x181>
lea    (%rsp,%rbx,4),%r15
add    $0xffffffffffffff90,%r15
add    %r9,%rbx
lea    (%rdi,%rbx,4),%r12
add    $0x10,%r12
shl    $0x5,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%r12,%rbx,1),%xmm0
movups (%r12,%rbx,1),%xmm1
movdqa %xmm0,-0x10(%r15,%rbx,1)
movaps %xmm1,(%r15,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    1260 <get_upupright_pred+0x160>
cmp    %r11,%rax
je     12a1 <get_upupright_pred+0x1a1>
lea    (%rdi,%r9,4),%r9
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rax,4),%ebx
mov    %ebx,-0x80(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r11
jne    1290 <get_upupright_pred+0x190>
lea    (%r8,%r8,1),%r9d
test   %r10d,%r10d
je     13a5 <get_upupright_pred+0x2a5>
cmp    %r8d,%r9d
jle    159d <get_upupright_pred+0x49d>
add    $0xffffffff,%esi
imul   %ecx,%esi
add    %edx,%esi
movslq %r8d,%rax
movslq %esi,%r10
movslq %r9d,%r13
mov    %r13,%r12
sub    %rax,%r12
cmp    $0x8,%r12
jb     1380 <get_upupright_pred+0x280>
mov    %r12,%r14
and    $0xfffffffffffffff8,%r14
lea    -0x8(%r14),%rcx
mov    %rcx,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rcx,%rcx
je     14f6 <get_upupright_pred+0x3f6>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
and    %r15,%rdx
lea    (%rsp,%rax,4),%rsi
add    $0xffffffffffffffb0,%rsi
lea    (%rax,%r10,1),%rcx
lea    (%rdi,%rcx,4),%rcx
add    $0x30,%rcx
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x30(%rcx,%rbx,4),%xmm0
movups -0x20(%rcx,%rbx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,4)
movups %xmm1,-0x20(%rsi,%rbx,4)
movdqu -0x10(%rcx,%rbx,4),%xmm0
movups (%rcx,%rbx,4),%xmm1
movdqu %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm1,(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1320 <get_upupright_pred+0x220>
test   $0x1,%r15b
je     1374 <get_upupright_pred+0x274>
add    %rax,%rbx
lea    (%rbx,%r10,1),%rcx
movdqu (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movdqu %xmm0,-0x80(%rsp,%rbx,4)
movups %xmm1,-0x70(%rsp,%rbx,4)
cmp    %r14,%r12
je     159d <get_upupright_pred+0x49d>
add    %r14,%rax
lea    (%rdi,%r10,4),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rcx,%rax,4),%edx
mov    %edx,-0x80(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    1390 <get_upupright_pred+0x290>
jmp    159d <get_upupright_pred+0x49d>
cmp    %r8d,%r9d
jle    159d <get_upupright_pred+0x49d>
add    $0xffffffff,%esi
imul   %ecx,%esi
add    %esi,%edx
lea    (%r8,%rdx,1),%eax
add    $0xffffffff,%eax
cltq
mov    (%rdi,%rax,4),%eax
movslq %r8d,%rcx
movslq %r9d,%rdx
mov    %rdx,%r14
sub    %rcx,%r14
cmp    $0x8,%r14
jb     1590 <get_upupright_pred+0x490>
mov    %r14,%r10
and    $0xfffffffffffffff8,%r10
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r10),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x18,%rsi
jae    1507 <get_upupright_pred+0x407>
xor    %esi,%esi
jmp    1559 <get_upupright_pred+0x459>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
add    $0xfffffffffffffffc,%rdi
and    %rdi,%rsi
xor    %edi,%edi
movdqa 0xbd6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,-0x80(%rsp,%rdi,4)
movdqa %xmm0,-0x70(%rsp,%rdi,4)
movdqa %xmm0,-0x60(%rsp,%rdi,4)
movdqa %xmm0,-0x50(%rsp,%rdi,4)
movdqa %xmm0,-0x40(%rsp,%rdi,4)
movdqa %xmm0,-0x30(%rsp,%rdi,4)
movdqa %xmm0,-0x20(%rsp,%rdi,4)
movdqa %xmm0,-0x10(%rsp,%rdi,4)
movdqa %xmm0,(%rsp,%rdi,4)
movdqa %xmm0,0x10(%rsp,%rdi,4)
movdqa %xmm0,0x20(%rsp,%rdi,4)
movdqa %xmm0,0x30(%rsp,%rdi,4)
movdqa %xmm0,0x40(%rsp,%rdi,4)
movdqa %xmm0,0x50(%rsp,%rdi,4)
movdqa %xmm0,0x60(%rsp,%rdi,4)
movdqa %xmm0,0x70(%rsp,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    1430 <get_upupright_pred+0x330>
test   %rdx,%rdx
je     14d4 <get_upupright_pred+0x3d4>
lea    (%rsp,%rdi,4),%rsi
add    $0xffffffffffffff90,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xb4c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,-0x10(%rsi,%rdi,1)
movdqa %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    14c0 <get_upupright_pred+0x3c0>
cmp    %rcx,%rax
je     159d <get_upupright_pred+0x49d>
nopl   (%rax)
movl   $0x80,-0x80(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    14e0 <get_upupright_pred+0x3e0>
jmp    159d <get_upupright_pred+0x49d>
xor    %ebx,%ebx
test   $0x1,%r15b
jne    1358 <get_upupright_pred+0x258>
jmp    1374 <get_upupright_pred+0x274>
and    $0xfffffffffffffffc,%rbx
lea    (%rsp,%rcx,4),%rdi
add    $0xfffffffffffffff0,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,-0x70(%rdi,%rsi,4)
movdqu %xmm0,-0x60(%rdi,%rsi,4)
movdqu %xmm0,-0x50(%rdi,%rsi,4)
movdqu %xmm0,-0x40(%rdi,%rsi,4)
movdqu %xmm0,-0x30(%rdi,%rsi,4)
movdqu %xmm0,-0x20(%rdi,%rsi,4)
movdqu %xmm0,-0x10(%rdi,%rsi,4)
movdqu %xmm0,(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1520 <get_upupright_pred+0x420>
test   %r15,%r15
je     1584 <get_upupright_pred+0x484>
add    %rcx,%rsi
lea    (%rsp,%rsi,4),%rsi
add    $0xffffffffffffff90,%rsi
shl    $0x5,%r15
xor    %edi,%edi
nop
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r15
jne    1570 <get_upupright_pred+0x470>
cmp    %r10,%r14
je     159d <get_upupright_pred+0x49d>
add    %r10,%rcx
nopl   0x0(%rax)
mov    %eax,-0x80(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1590 <get_upupright_pred+0x490>
mov    -0x80(%rsp),%r12d
mov    -0x7c(%rsp),%edx
lea    (%r12,%r12,2),%eax
add    %edx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,0x180(%rsp)
lea    -0x1(%r9),%r10d
cmp    $0x2,%r8d
jl     1663 <get_upupright_pred+0x563>
cmp    $0x3,%r10d
mov    $0x2,%r14d
cmovge %r10d,%r14d
add    $0xffffffffffffffff,%r14
mov    $0x1,%ecx
cmp    $0x3,%r10d
jge    15eb <get_upupright_pred+0x4eb>
mov    %edx,%edi
mov    %r12d,%esi
jmp    1647 <get_upupright_pred+0x547>
mov    %r14,%r15
and    $0xfffffffffffffffe,%r15
neg    %r15
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x7c(%rsp,%rax,4),%esi
mov    -0x78(%rsp,%rax,4),%edi
lea    (%r12,%rdx,2),%ecx
add    %esi,%ecx
add    $0x2,%ecx
sar    $0x2,%ecx
mov    %ecx,0x180(%rsp,%rax,4)
lea    0x2(%rax),%rcx
lea    (%rdx,%rsi,2),%edx
add    %edi,%edx
add    $0x2,%edx
sar    $0x2,%edx
mov    %edx,0x184(%rsp,%rax,4)
lea    (%r15,%rax,1),%rbx
add    $0x2,%rbx
mov    %edi,%edx
mov    %esi,%r12d
mov    %rcx,%rax
cmp    $0x1,%rbx
jne    1600 <get_upupright_pred+0x500>
test   $0x1,%r14b
je     1663 <get_upupright_pred+0x563>
mov    -0x7c(%rsp,%rcx,4),%eax
lea    (%rsi,%rdi,2),%edx
add    %edx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,0x180(%rsp,%rcx,4)
movslq %r9d,%rax
movslq %r10d,%rcx
mov    -0x80(%rsp,%rcx,4),%edx
mov    -0x88(%rsp,%rax,4),%eax
add    %edx,%eax
lea    (%rax,%rdx,2),%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,0x180(%rsp,%rcx,4)
test   %r8d,%r8d
jle    170c <get_upupright_pred+0x60c>
mov    0x3b0(%rsp),%rax
lea    0x0(,%r11,4),%r8
lea    (%r11,%r11,1),%r10
mov    $0x1,%r9d
xor    %edi,%edi
jmp    16c0 <get_upupright_pred+0x5c0>
nopl   (%rax)
add    $0x1,%rdi
add    %r8,%rax
add    $0x1,%r9
cmp    %r11,%rdi
je     170c <get_upupright_pred+0x60c>
mov    %r9,%rdx
shr    %rdx
xor    %ecx,%ecx
jmp    16f5 <get_upupright_pred+0x5f5>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%esi
shr    %esi
mov    0x184(%rsp,%rsi,4),%ebx
add    0x180(%rsp,%rsi,4),%ebx
sar    %ebx
mov    %ebx,(%rax,%rcx,2)
add    $0x2,%rcx
add    $0x1,%rdx
cmp    %rcx,%r10
je     16b0 <get_upupright_pred+0x5b0>
test   $0x1,%dil
je     16d0 <get_upupright_pred+0x5d0>
mov    %edx,%esi
and    $0x7fffffff,%esi
mov    0x180(%rsp,%rsi,4),%ebx
jmp    16e5 <get_upupright_pred+0x5e5>
add    $0x380,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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