void v4lconvert_spca505_to_yuv420(const unsigned char *src, unsigned char *dst,
                                  int width, int height, int yvu) {
  int i, j;
  unsigned long *lsrc = (unsigned long *)src;
  for (i = 0; i < height; i += 2) {
    unsigned long *ldst = (unsigned long *)(dst + i * width);
    for (j = 0; j < width * 2; j += sizeof(long)) {
      *ldst = *lsrc++;
      *ldst++ ^= 0x8080808080808080ULL;
    }
    if (yvu)
      ldst = (unsigned long *)(dst + (width * height * 5) / 4 + i * width / 4);
    else
      ldst = (unsigned long *)(dst + width * height + i * width / 4);
    for (j = 0; j < width / 2; j += sizeof(long)) {
      *ldst = *lsrc++;
      *ldst++ ^= 0x8080808080808080ULL;
    }
    if (yvu)
      ldst = (unsigned long *)(dst + width * height + i * width / 4);
    else
      ldst = (unsigned long *)(dst + (width * height * 5) / 4 + i * width / 4);
    for (j = 0; j < width / 2; j += sizeof(long)) {
      *ldst = *lsrc++;
      *ldst++ ^= 0x8080808080808080ULL;
    }
  }
}


x86 assembly (clang, -O0):
<v4lconvert_spca505_to_yuv420>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13ab <v4lconvert_spca505_to_yuv420+0x2ab>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    11a6 <v4lconvert_spca505_to_yuv420+0xa6>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movabs $0x8080808080808080,%rcx
80 80 80
xor    (%rax),%rcx
mov    %rcx,(%rax)
movslq -0x24(%rbp),%rax
add    $0x8,%rax
mov    %eax,-0x24(%rbp)
jmp    114d <v4lconvert_spca505_to_yuv420+0x4d>
cmpl   $0x0,-0x1c(%rbp)
je     11fe <v4lconvert_spca505_to_yuv420+0xfe>
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   $0x5,%eax,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1232 <v4lconvert_spca505_to_yuv420+0x132>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
cmp    %ecx,%eax
jge    129f <v4lconvert_spca505_to_yuv420+0x19f>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movabs $0x8080808080808080,%rcx
80 80 80
xor    (%rax),%rcx
mov    %rcx,(%rax)
movslq -0x24(%rbp),%rax
add    $0x8,%rax
mov    %eax,-0x24(%rbp)
jmp    1239 <v4lconvert_spca505_to_yuv420+0x139>
cmpl   $0x0,-0x1c(%rbp)
je     12e2 <v4lconvert_spca505_to_yuv420+0x1e2>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    132b <v4lconvert_spca505_to_yuv420+0x22b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   $0x5,%eax,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
cmp    %ecx,%eax
jge    1398 <v4lconvert_spca505_to_yuv420+0x298>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movabs $0x8080808080808080,%rcx
80 80 80
xor    (%rax),%rcx
mov    %rcx,(%rax)
movslq -0x24(%rbp),%rax
add    $0x8,%rax
mov    %eax,-0x24(%rbp)
jmp    1332 <v4lconvert_spca505_to_yuv420+0x232>
jmp    139d <v4lconvert_spca505_to_yuv420+0x29d>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    1125 <v4lconvert_spca505_to_yuv420+0x25>
pop    %rbp
ret

x86 assembly (clang, -O2):
<v4lconvert_spca505_to_yuv420>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x40,%rsp
test   %ecx,%ecx
jle    1600 <v4lconvert_spca505_to_yuv420+0x500>
mov    %ecx,%eax
imul   %edx,%eax
lea    (%rax,%rax,4),%ebx
lea    (%rax,%rax,4),%ebp
add    $0x3,%ebp
test   %ebx,%ebx
cmovns %ebx,%ebp
lea    (%rdx,%rdx,1),%r10d
sar    $0x2,%ebp
movslq %ebp,%r9
add    %rsi,%r9
movslq %eax,%r15
add    %rsi,%r15
mov    %edx,%eax
shr    $0x1f,%eax
add    %edx,%eax
sar    %eax
lea    -0x1(%rax),%ebx
mov    %rsi,-0x80(%rsp)
mov    %ebx,-0x74(%rsp)
mov    %ebx,%r11d
shr    $0x3,%r11d
mov    %r11d,%ebx
add    $0x1,%ebx
cmp    $0x9,%r10d
mov    $0x8,%esi
cmovge %r10d,%esi
add    $0xfffffffe,%esi
mov    %esi,-0x6c(%rsp)
mov    %esi,%r14d
shr    $0x3,%r14d
mov    %r14d,%esi
add    $0x1,%esi
mov    %rsi,(%rsp)
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rbp
mov    %rbp,-0x10(%rsp)
mov    %rbp,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %rbx,-0x48(%rsp)
mov    %ebx,%r12d
and    $0xfffffffc,%r12d
lea    -0x4(%r12),%rbx
mov    %rbx,-0x58(%rsp)
mov    %rbx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r13,%rbx
mov    %r13,-0x18(%rsp)
and    $0xfffffffffffffffe,%r13
mov    %r13,-0x20(%rsp)
mov    %rbp,%rbx
mov    %rbp,-0x60(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x68(%rsp)
test   %r8d,%r8d
mov    %r9,%rbp
cmove  %r15,%rbp
cmove  %r9,%r15
lea    0x1(%r14),%rbx
mov    %rbx,0x20(%rsp)
lea    0x8(,%r14,8),%rbx
mov    %rbx,0x18(%rsp)
mov    %ecx,%ecx
mov    %rcx,0x38(%rsp)
lea    0x1(%r11),%rcx
mov    %rcx,-0x40(%rsp)
lea    0x8(%rbp,%r11,8),%rcx
mov    %rcx,0x10(%rsp)
lea    0x8(%r15,%r11,8),%rcx
mov    %rcx,0x8(%rsp)
mov    -0x80(%rsp),%rbx
movaps 0xdcf(%rip),%xmm0
movabs $0x8080808080808080,%r8
80 80 80
movslq %edx,%r14
lea    (%r14,%r14,1),%rcx
mov    %rcx,-0x38(%rsp)
mov    %rsi,-0x8(%rsp)
lea    0x0(,%rsi,8),%ecx
mov    %ecx,-0x70(%rsp)
mov    %r12,-0x50(%rsp)
lea    0x0(,%r12,8),%ecx
mov    %ecx,-0x78(%rsp)
lea    0x30(%rbx),%r12
mov    %rbp,0x28(%rsp)
lea    0x30(%rbp),%rcx
mov    %rcx,-0x28(%rsp)
mov    %r15,0x30(%rsp)
lea    0x30(%r15),%rcx
mov    %rcx,-0x30(%rsp)
xor    %r9d,%r9d
xor    %r13d,%r13d
jmp    12ad <v4lconvert_spca505_to_yuv420+0x1ad>
mov    -0x80(%rsp),%rbx
add    $0x2,%r13
add    $0x1,%r9
add    -0x38(%rsp),%r12
cmp    0x38(%rsp),%r13
jae    1600 <v4lconvert_spca505_to_yuv420+0x500>
mov    %r13,%r11
imul   %r14,%r11
test   %r14d,%r14d
jle    13b9 <v4lconvert_spca505_to_yuv420+0x2b9>
lea    (%rbx,%r11,1),%r15
xor    %ecx,%ecx
cmpl   $0x18,-0x6c(%rsp)
jb     13a0 <v4lconvert_spca505_to_yuv420+0x2a0>
mov    -0x38(%rsp),%rsi
imul   %r9,%rsi
mov    -0x80(%rsp),%rbx
add    %rsi,%rbx
mov    0x20(%rsp),%rbp
lea    (%rdi,%rbp,8),%rbp
cmp    %rbp,%rbx
mov    -0x80(%rsp),%rbx
jae    1303 <v4lconvert_spca505_to_yuv420+0x203>
add    0x18(%rsp),%rsi
add    %rbx,%rsi
cmp    %rdi,%rsi
ja     13a0 <v4lconvert_spca505_to_yuv420+0x2a0>
cmpq   $0x0,-0x10(%rsp)
je     15cd <v4lconvert_spca505_to_yuv420+0x4cd>
mov    -0x20(%rsp),%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rcx,8),%xmm1
movups 0x10(%rdi,%rcx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x30(%r12,%rcx,8)
movups %xmm2,-0x20(%r12,%rcx,8)
movups 0x20(%rdi,%rcx,8),%xmm1
movups 0x30(%rdi,%rcx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%r12,%rcx,8)
movups %xmm2,(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1320 <v4lconvert_spca505_to_yuv420+0x220>
testb  $0x1,-0x18(%rsp)
je     1381 <v4lconvert_spca505_to_yuv420+0x281>
movups (%rdi,%rcx,8),%xmm1
movups 0x10(%rdi,%rcx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,(%r15,%rcx,8)
movups %xmm2,0x10(%r15,%rcx,8)
mov    -0x8(%rsp),%rcx
lea    (%rdi,%rcx,8),%rdi
cmp    (%rsp),%rcx
je     13b9 <v4lconvert_spca505_to_yuv420+0x2b9>
lea    (%r15,%rcx,8),%r15
mov    -0x70(%rsp),%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rdi),%rsi
xor    %r8,%rsi
add    $0x8,%rdi
mov    %rsi,(%r15)
add    $0x8,%r15
add    $0x8,%ecx
cmp    %r10d,%ecx
jl     13a0 <v4lconvert_spca505_to_yuv420+0x2a0>
cmp    $0x2,%edx
jl     14b8 <v4lconvert_spca505_to_yuv420+0x3b8>
lea    0x3(%r11),%ecx
test   %r11d,%r11d
cmovns %r11d,%ecx
sar    $0x2,%ecx
movslq %ecx,%rbp
mov    0x28(%rsp),%rcx
add    %rbp,%rcx
xor    %ebx,%ebx
cmpl   $0x18,-0x74(%rsp)
jb     14a0 <v4lconvert_spca505_to_yuv420+0x3a0>
mov    -0x40(%rsp),%rsi
lea    (%rdi,%rsi,8),%rsi
cmp    %rsi,%rcx
jae    1407 <v4lconvert_spca505_to_yuv420+0x307>
mov    0x10(%rsp),%rsi
add    %rbp,%rsi
cmp    %rdi,%rsi
ja     14a0 <v4lconvert_spca505_to_yuv420+0x3a0>
cmpq   $0x0,-0x58(%rsp)
je     15df <v4lconvert_spca505_to_yuv420+0x4df>
add    -0x28(%rsp),%rbp
mov    -0x68(%rsp),%rsi
xor    %ebx,%ebx
nop
movups (%rdi,%rbx,8),%xmm1
movups 0x10(%rdi,%rbx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x30(%rbp,%rbx,8)
movups %xmm2,-0x20(%rbp,%rbx,8)
movups 0x20(%rdi,%rbx,8),%xmm1
movups 0x30(%rdi,%rbx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rbp,%rbx,8)
movups %xmm2,0x0(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1420 <v4lconvert_spca505_to_yuv420+0x320>
testb  $0x1,-0x60(%rsp)
je     147c <v4lconvert_spca505_to_yuv420+0x37c>
movups (%rdi,%rbx,8),%xmm1
movups 0x10(%rdi,%rbx,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rbx,8)
movups %xmm2,0x10(%rcx,%rbx,8)
mov    -0x50(%rsp),%rsi
lea    (%rdi,%rsi,8),%rdi
cmp    -0x48(%rsp),%rsi
je     14b8 <v4lconvert_spca505_to_yuv420+0x3b8>
lea    (%rcx,%rsi,8),%rcx
mov    -0x78(%rsp),%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi),%rsi
xor    %r8,%rsi
add    $0x8,%rdi
mov    %rsi,(%rcx)
add    $0x8,%rcx
add    $0x8,%ebx
cmp    %eax,%ebx
jl     14a0 <v4lconvert_spca505_to_yuv420+0x3a0>
cmp    $0x2,%edx
jl     1290 <v4lconvert_spca505_to_yuv420+0x190>
lea    0x3(%r11),%ecx
test   %r11d,%r11d
cmovns %r11d,%ecx
sar    $0x2,%ecx
movslq %ecx,%rbx
mov    0x30(%rsp),%rcx
add    %rbx,%rcx
xor    %ebp,%ebp
cmpl   $0x18,-0x74(%rsp)
jae    14f0 <v4lconvert_spca505_to_yuv420+0x3f0>
mov    -0x80(%rsp),%rbx
jmp    15b0 <v4lconvert_spca505_to_yuv420+0x4b0>
nopl   (%rax)
mov    -0x40(%rsp),%rsi
lea    (%rdi,%rsi,8),%rsi
cmp    %rsi,%rcx
jae    1515 <v4lconvert_spca505_to_yuv420+0x415>
mov    0x8(%rsp),%rsi
add    %rbx,%rsi
cmp    %rdi,%rsi
jbe    1515 <v4lconvert_spca505_to_yuv420+0x415>
mov    -0x80(%rsp),%rbx
jmp    15b0 <v4lconvert_spca505_to_yuv420+0x4b0>
cmpq   $0x0,-0x58(%rsp)
je     15f1 <v4lconvert_spca505_to_yuv420+0x4f1>
add    -0x30(%rsp),%rbx
mov    -0x68(%rsp),%rsi
xor    %ebp,%ebp
nopl   (%rax)
movups (%rdi,%rbp,8),%xmm1
movups 0x10(%rdi,%rbp,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x30(%rbx,%rbp,8)
movups %xmm2,-0x20(%rbx,%rbp,8)
movups 0x20(%rdi,%rbp,8),%xmm1
movups 0x30(%rdi,%rbp,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,-0x10(%rbx,%rbp,8)
movups %xmm2,(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1530 <v4lconvert_spca505_to_yuv420+0x430>
testb  $0x1,-0x60(%rsp)
je     158b <v4lconvert_spca505_to_yuv420+0x48b>
movups (%rdi,%rbp,8),%xmm1
movups 0x10(%rdi,%rbp,8),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rbp,8)
movups %xmm2,0x10(%rcx,%rbp,8)
mov    -0x50(%rsp),%rsi
lea    (%rdi,%rsi,8),%rdi
cmp    -0x48(%rsp),%rsi
mov    -0x80(%rsp),%rbx
je     1295 <v4lconvert_spca505_to_yuv420+0x195>
lea    (%rcx,%rsi,8),%rcx
mov    -0x78(%rsp),%ebp
nopl   0x0(%rax)
mov    (%rdi),%rsi
xor    %r8,%rsi
add    $0x8,%rdi
mov    %rsi,(%rcx)
add    $0x8,%rcx
add    $0x8,%ebp
cmp    %eax,%ebp
jl     15b0 <v4lconvert_spca505_to_yuv420+0x4b0>
jmp    1295 <v4lconvert_spca505_to_yuv420+0x195>
xor    %ecx,%ecx
testb  $0x1,-0x18(%rsp)
jne    1367 <v4lconvert_spca505_to_yuv420+0x267>
jmp    1381 <v4lconvert_spca505_to_yuv420+0x281>
xor    %ebx,%ebx
testb  $0x1,-0x60(%rsp)
jne    1464 <v4lconvert_spca505_to_yuv420+0x364>
jmp    147c <v4lconvert_spca505_to_yuv420+0x37c>
xor    %ebp,%ebp
testb  $0x1,-0x60(%rsp)
jne    1573 <v4lconvert_spca505_to_yuv420+0x473>
jmp    158b <v4lconvert_spca505_to_yuv420+0x48b>
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @v4lconvert_spca505_to_yuv420(i8* nocapture %0, i8* nocapture writeonly %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp sgt i32 %3, 0
br i1 %6, label %7, label %343
7: ; preds = %5
%8 = bitcast i8* %0 to i64*
%9 = shl i32 %2, 1
%10 = icmp sgt i32 %2, 0
%11 = icmp eq i32 %4, 0
%12 = mul nsw i32 %3, %2
%13 = mul nsw i32 %12, 5
%14 = sdiv i32 %13, 4
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %1, i64 %15
%17 = sext i32 %12 to i64
%18 = getelementptr inbounds i8, i8* %1, i64 %17
%19 = sdiv i32 %2, 2
%20 = icmp sgt i32 %2, 1
%21 = sext i32 %2 to i64
%22 = zext i32 %3 to i64
%23 = add nsw i32 %19, -1
%24 = lshr i32 %23, 3
%25 = zext i32 %24 to i64
%26 = shl nuw nsw i64 %25, 3
%27 = add nuw nsw i64 %26, 8
%28 = add nuw nsw i64 %25, 1
%29 = add nsw i32 %19, -1
%30 = lshr i32 %29, 3
%31 = add nuw nsw i32 %30, 1
%32 = zext i32 %31 to i64
%33 = add nsw i32 %19, -1
%34 = lshr i32 %33, 3
%35 = zext i32 %34 to i64
%36 = shl nuw nsw i64 %35, 3
%37 = add nuw nsw i64 %36, 8
%38 = add nuw nsw i64 %35, 1
%39 = add nsw i32 %19, -1
%40 = lshr i32 %39, 3
%41 = add nuw nsw i32 %40, 1
%42 = zext i32 %41 to i64
%43 = shl nsw i64 %21, 1
%44 = call i32 @llvm.smax.i32(i32 %9, i32 8)
%45 = add nsw i32 %44, -2
%46 = lshr i32 %45, 3
%47 = zext i32 %46 to i64
%48 = shl nuw nsw i64 %47, 3
%49 = add nuw nsw i64 %48, 8
%50 = add nuw nsw i64 %47, 1
%51 = call i32 @llvm.smax.i32(i32 %9, i32 8)
%52 = add nsw i32 %51, -2
%53 = lshr i32 %52, 3
%54 = add nuw nsw i32 %53, 1
%55 = zext i32 %54 to i64
%56 = and i64 %55, 1073741820
%57 = add nsw i64 %56, -4
%58 = lshr exact i64 %57, 2
%59 = add nuw nsw i64 %58, 1
%60 = and i64 %42, 1073741820
%61 = add nsw i64 %60, -4
%62 = lshr exact i64 %61, 2
%63 = add nuw nsw i64 %62, 1
%64 = icmp ult i32 %52, 24
%65 = and i64 %55, 1073741820
%66 = trunc i64 %65 to i32
%67 = shl i32 %66, 3
%68 = and i64 %59, 1
%69 = icmp eq i64 %57, 0
%70 = and i64 %59, 9223372036854775806
%71 = icmp eq i64 %68, 0
%72 = icmp eq i64 %65, %55
%73 = select i1 %11, i8* %18, i8* %16
%74 = icmp ult i32 %39, 24
%75 = getelementptr i8, i8* %73, i64 %37
%76 = and i64 %42, 1073741820
%77 = trunc i64 %76 to i32
%78 = shl i32 %77, 3
%79 = and i64 %63, 1
%80 = icmp eq i64 %61, 0
%81 = and i64 %63, 9223372036854775806
%82 = icmp eq i64 %79, 0
%83 = icmp eq i64 %76, %42
%84 = select i1 %11, i8* %16, i8* %18
%85 = icmp ult i32 %29, 24
%86 = getelementptr i8, i8* %84, i64 %27
%87 = and i64 %32, 1073741820
%88 = trunc i64 %87 to i32
%89 = shl i32 %88, 3
%90 = and i64 %63, 1
%91 = icmp eq i64 %61, 0
%92 = and i64 %63, 9223372036854775806
%93 = icmp eq i64 %90, 0
%94 = icmp eq i64 %87, %32
br label %95
95: ; preds = %7, %338
%96 = phi i64 [ 0, %7 ], [ %342, %338 ]
%97 = phi i64 [ 0, %7 ], [ %340, %338 ]
%98 = phi i64* [ %8, %7 ], [ %339, %338 ]
%99 = bitcast i64* %98 to i8*
%100 = mul i64 %43, %96
%101 = getelementptr i8, i8* %1, i64 %100
%102 = add i64 %49, %100
%103 = getelementptr i8, i8* %1, i64 %102
%104 = mul nsw i64 %97, %21
br i1 %10, label %105, label %178
105: ; preds = %95
%106 = getelementptr inbounds i8, i8* %1, i64 %104
%107 = bitcast i8* %106 to i64*
br i1 %64, label %164, label %108
108: ; preds = %105
%109 = getelementptr i64, i64* %98, i64 %50
%110 = bitcast i64* %109 to i8*
%111 = icmp ult i8* %101, %110
%112 = icmp ugt i8* %103, %99
%113 = and i1 %111, %112
br i1 %113, label %164, label %114
114: ; preds = %108
%115 = getelementptr i64, i64* %107, i64 %65
%116 = getelementptr i64, i64* %98, i64 %65
br i1 %69, label %148, label %117
117: ; preds = %114, %117
%118 = phi i64 [ %145, %117 ], [ 0, %114 ]
%119 = phi i64 [ %146, %117 ], [ 0, %114 ]
%120 = getelementptr i64, i64* %107, i64 %118
%121 = getelementptr i64, i64* %98, i64 %118
%122 = bitcast i64* %121 to <2 x i64>*
%123 = load <2 x i64>, <2 x i64>* %122
%124 = getelementptr i64, i64* %121, i64 2
%125 = bitcast i64* %124 to <2 x i64>*
%126 = load <2 x i64>, <2 x i64>* %125
%127 = xor <2 x i64> %123, <i64 -9187201950435737472, i64 -9187201950435737472>
%128 = xor <2 x i64> %126, <i64 -9187201950435737472, i64 -9187201950435737472>
%129 = bitcast i64* %120 to <2 x i64>*
store <2 x i64> %127, <2 x i64>* %129
%130 = getelementptr i64, i64* %120, i64 2
%131 = bitcast i64* %130 to <2 x i64>*
store <2 x i64> %128, <2 x i64>* %131
%132 = or i64 %118, 4
%133 = getelementptr i64, i64* %107, i64 %132
%134 = getelementptr i64, i64* %98, i64 %132
%135 = bitcast i64* %134 to <2 x i64>*
%136 = load <2 x i64>, <2 x i64>* %135
%137 = getelementptr i64, i64* %134, i64 2
%138 = bitcast i64* %137 to <2 x i64>*
%139 = load <2 x i64>, <2 x i64>* %138
%140 = xor <2 x i64> %136, <i64 -9187201950435737472, i64 -9187201950435737472>
%141 = xor <2 x i64> %139, <i64 -9187201950435737472, i64 -9187201950435737472>
%142 = bitcast i64* %133 to <2 x i64>*
store <2 x i64> %140, <2 x i64>* %142
%143 = getelementptr i64, i64* %133, i64 2
%144 = bitcast i64* %143 to <2 x i64>*
store <2 x i64> %141, <2 x i64>* %144
%145 = add nuw i64 %118, 8
%146 = add i64 %119, 2
%147 = icmp eq i64 %146, %70
br i1 %147, label %148, label %117
148: ; preds = %117, %114
%149 = phi i64 [ 0, %114 ], [ %145, %117 ]
br i1 %71, label %163, label %150
150: ; preds = %148
%151 = getelementptr i64, i64* %107, i64 %149
%152 = getelementptr i64, i64* %98, i64 %149
%153 = bitcast i64* %152 to <2 x i64>*
%154 = load <2 x i64>, <2 x i64>* %153
%155 = getelementptr i64, i64* %152, i64 2
%156 = bitcast i64* %155 to <2 x i64>*
%157 = load <2 x i64>, <2 x i64>* %156
%158 = xor <2 x i64> %154, <i64 -9187201950435737472, i64 -9187201950435737472>
%159 = xor <2 x i64> %157, <i64 -9187201950435737472, i64 -9187201950435737472>
%160 = bitcast i64* %151 to <2 x i64>*
store <2 x i64> %158, <2 x i64>* %160
%161 = getelementptr i64, i64* %151, i64 2
%162 = bitcast i64* %161 to <2 x i64>*
store <2 x i64> %159, <2 x i64>* %162
br label %163
163: ; preds = %148, %150
br i1 %72, label %178, label %164
164: ; preds = %108, %105, %163
%165 = phi i64* [ %107, %108 ], [ %107, %105 ], [ %115, %163 ]
%166 = phi i64* [ %98, %108 ], [ %98, %105 ], [ %116, %163 ]
%167 = phi i32 [ 0, %108 ], [ 0, %105 ], [ %67, %163 ]
br label %168
168: ; preds = %164, %168
%169 = phi i64* [ %174, %168 ], [ %165, %164 ]
%170 = phi i64* [ %172, %168 ], [ %166, %164 ]
%171 = phi i32 [ %176, %168 ], [ %167, %164 ]
%172 = getelementptr inbounds i64, i64* %170, i64 1
%173 = load i64, i64* %170
%174 = getelementptr inbounds i64, i64* %169, i64 1
%175 = xor i64 %173, -9187201950435737472
store i64 %175, i64* %169
%176 = add nuw nsw i32 %171, 8
%177 = icmp slt i32 %176, %9
br i1 %177, label %168, label %178
178: ; preds = %168, %163, %95
%179 = phi i64* [ %98, %95 ], [ %116, %163 ], [ %172, %168 ]
%180 = bitcast i64* %179 to i8*
br i1 %20, label %181, label %258
181: ; preds = %178
%182 = trunc i64 %104 to i32
%183 = sdiv i32 %182, 4
%184 = sext i32 %183 to i64
%185 = getelementptr i8, i8* %73, i64 %184
%186 = bitcast i8* %185 to i64*
br i1 %74, label %244, label %187
187: ; preds = %181
%188 = getelementptr i8, i8* %75, i64 %184
%189 = getelementptr i64, i64* %179, i64 %38
%190 = bitcast i64* %189 to i8*
%191 = icmp ult i8* %185, %190
%192 = icmp ugt i8* %188, %180
%193 = and i1 %191, %192
br i1 %193, label %244, label %194
194: ; preds = %187
%195 = getelementptr i64, i64* %186, i64 %76
%196 = getelementptr i64, i64* %179, i64 %76
br i1 %80, label %228, label %197
197: ; preds = %194, %197
%198 = phi i64 [ %225, %197 ], [ 0, %194 ]
%199 = phi i64 [ %226, %197 ], [ 0, %194 ]
%200 = getelementptr i64, i64* %186, i64 %198
%201 = getelementptr i64, i64* %179, i64 %198
%202 = bitcast i64* %201 to <2 x i64>*
%203 = load <2 x i64>, <2 x i64>* %202
%204 = getelementptr i64, i64* %201, i64 2
%205 = bitcast i64* %204 to <2 x i64>*
%206 = load <2 x i64>, <2 x i64>* %205
%207 = xor <2 x i64> %203, <i64 -9187201950435737472, i64 -9187201950435737472>
%208 = xor <2 x i64> %206, <i64 -9187201950435737472, i64 -9187201950435737472>
%209 = bitcast i64* %200 to <2 x i64>*
store <2 x i64> %207, <2 x i64>* %209
%210 = getelementptr i64, i64* %200, i64 2
%211 = bitcast i64* %210 to <2 x i64>*
store <2 x i64> %208, <2 x i64>* %211
%212 = or i64 %198, 4
%213 = getelementptr i64, i64* %186, i64 %212
%214 = getelementptr i64, i64* %179, i64 %212
%215 = bitcast i64* %214 to <2 x i64>*
%216 = load <2 x i64>, <2 x i64>* %215
%217 = getelementptr i64, i64* %214, i64 2
%218 = bitcast i64* %217 to <2 x i64>*
%219 = load <2 x i64>, <2 x i64>* %218
%220 = xor <2 x i64> %216, <i64 -9187201950435737472, i64 -9187201950435737472>
%221 = xor <2 x i64> %219, <i64 -9187201950435737472, i64 -9187201950435737472>
%222 = bitcast i64* %213 to <2 x i64>*
store <2 x i64> %220, <2 x i64>* %222
%223 = getelementptr i64, i64* %213, i64 2
%224 = bitcast i64* %223 to <2 x i64>*
store <2 x i64> %221, <2 x i64>* %224
%225 = add nuw i64 %198, 8
%226 = add i64 %199, 2
%227 = icmp eq i64 %226, %81
br i1 %227, label %228, label %197
228: ; preds = %197, %194
%229 = phi i64 [ 0, %194 ], [ %225, %197 ]
br i1 %82, label %243, label %230
230: ; preds = %228
%231 = getelementptr i64, i64* %186, i64 %229
%232 = getelementptr i64, i64* %179, i64 %229
%233 = bitcast i64* %232 to <2 x i64>*
%234 = load <2 x i64>, <2 x i64>* %233
%235 = getelementptr i64, i64* %232, i64 2
%236 = bitcast i64* %235 to <2 x i64>*
%237 = load <2 x i64>, <2 x i64>* %236
%238 = xor <2 x i64> %234, <i64 -9187201950435737472, i64 -9187201950435737472>
%239 = xor <2 x i64> %237, <i64 -9187201950435737472, i64 -9187201950435737472>
%240 = bitcast i64* %231 to <2 x i64>*
store <2 x i64> %238, <2 x i64>* %240
%241 = getelementptr i64, i64* %231, i64 2
%242 = bitcast i64* %241 to <2 x i64>*
store <2 x i64> %239, <2 x i64>* %242
br label %243
243: ; preds = %228, %230
br i1 %83, label %258, label %244
244: ; preds = %187, %181, %243
%245 = phi i64* [ %186, %187 ], [ %186, %181 ], [ %195, %243 ]
%246 = phi i64* [ %179, %187 ], [ %179, %181 ], [ %196, %243 ]
%247 = phi i32 [ 0, %187 ], [ 0, %181 ], [ %78, %243 ]
br label %248
248: ; preds = %244, %248
%249 = phi i64* [ %254, %248 ], [ %245, %244 ]
%250 = phi i64* [ %252, %248 ], [ %246, %244 ]
%251 = phi i32 [ %256, %248 ], [ %247, %244 ]
%252 = getelementptr inbounds i64, i64* %250, i64 1
%253 = load i64, i64* %250
%254 = getelementptr inbounds i64, i64* %249, i64 1
%255 = xor i64 %253, -9187201950435737472
store i64 %255, i64* %249
%256 = add nuw nsw i32 %251, 8
%257 = icmp slt i32 %256, %19
br i1 %257, label %248, label %258
258: ; preds = %248, %243, %178
%259 = phi i64* [ %179, %178 ], [ %196, %243 ], [ %252, %248 ]
%260 = bitcast i64* %259 to i8*
br i1 %20, label %261, label %338
261: ; preds = %258
%262 = trunc i64 %104 to i32
%263 = sdiv i32 %262, 4
%264 = sext i32 %263 to i64
%265 = getelementptr i8, i8* %84, i64 %264
%266 = bitcast i8* %265 to i64*
br i1 %85, label %324, label %267
267: ; preds = %261
%268 = getelementptr i8, i8* %86, i64 %264
%269 = getelementptr i64, i64* %259, i64 %28
%270 = bitcast i64* %269 to i8*
%271 = icmp ult i8* %265, %270
%272 = icmp ugt i8* %268, %260
%273 = and i1 %271, %272
br i1 %273, label %324, label %274
274: ; preds = %267
%275 = getelementptr i64, i64* %266, i64 %87
%276 = getelementptr i64, i64* %259, i64 %87
br i1 %91, label %308, label %277
277: ; preds = %274, %277
%278 = phi i64 [ %305, %277 ], [ 0, %274 ]
%279 = phi i64 [ %306, %277 ], [ 0, %274 ]
%280 = getelementptr i64, i64* %266, i64 %278
%281 = getelementptr i64, i64* %259, i64 %278
%282 = bitcast i64* %281 to <2 x i64>*
%283 = load <2 x i64>, <2 x i64>* %282
%284 = getelementptr i64, i64* %281, i64 2
%285 = bitcast i64* %284 to <2 x i64>*
%286 = load <2 x i64>, <2 x i64>* %285
%287 = xor <2 x i64> %283, <i64 -9187201950435737472, i64 -9187201950435737472>
%288 = xor <2 x i64> %286, <i64 -9187201950435737472, i64 -9187201950435737472>
%289 = bitcast i64* %280 to <2 x i64>*
store <2 x i64> %287, <2 x i64>* %289
%290 = getelementptr i64, i64* %280, i64 2
%291 = bitcast i64* %290 to <2 x i64>*
store <2 x i64> %288, <2 x i64>* %291
%292 = or i64 %278, 4
%293 = getelementptr i64, i64* %266, i64 %292
%294 = getelementptr i64, i64* %259, i64 %292
%295 = bitcast i64* %294 to <2 x i64>*
%296 = load <2 x i64>, <2 x i64>* %295
%297 = getelementptr i64, i64* %294, i64 2
%298 = bitcast i64* %297 to <2 x i64>*
%299 = load <2 x i64>, <2 x i64>* %298
%300 = xor <2 x i64> %296, <i64 -9187201950435737472, i64 -9187201950435737472>
%301 = xor <2 x i64> %299, <i64 -9187201950435737472, i64 -9187201950435737472>
%302 = bitcast i64* %293 to <2 x i64>*
store <2 x i64> %300, <2 x i64>* %302
%303 = getelementptr i64, i64* %293, i64 2
%304 = bitcast i64* %303 to <2 x i64>*
store <2 x i64> %301, <2 x i64>* %304
%305 = add nuw i64 %278, 8
%306 = add i64 %279, 2
%307 = icmp eq i64 %306, %92
br i1 %307, label %308, label %277
308: ; preds = %277, %274
%309 = phi i64 [ 0, %274 ], [ %305, %277 ]
br i1 %93, label %323, label %310
310: ; preds = %308
%311 = getelementptr i64, i64* %266, i64 %309
%312 = getelementptr i64, i64* %259, i64 %309
%313 = bitcast i64* %312 to <2 x i64>*
%314 = load <2 x i64>, <2 x i64>* %313
%315 = getelementptr i64, i64* %312, i64 2
%316 = bitcast i64* %315 to <2 x i64>*
%317 = load <2 x i64>, <2 x i64>* %316
%318 = xor <2 x i64> %314, <i64 -9187201950435737472, i64 -9187201950435737472>
%319 = xor <2 x i64> %317, <i64 -9187201950435737472, i64 -9187201950435737472>
%320 = bitcast i64* %311 to <2 x i64>*
store <2 x i64> %318, <2 x i64>* %320
%321 = getelementptr i64, i64* %311, i64 2
%322 = bitcast i64* %321 to <2 x i64>*
store <2 x i64> %319, <2 x i64>* %322
br label %323
323: ; preds = %308, %310
br i1 %94, label %338, label %324
324: ; preds = %267, %261, %323
%325 = phi i64* [ %266, %267 ], [ %266, %261 ], [ %275, %323 ]
%326 = phi i64* [ %259, %267 ], [ %259, %261 ], [ %276, %323 ]
%327 = phi i32 [ 0, %267 ], [ 0, %261 ], [ %89, %323 ]
br label %328
328: ; preds = %324, %328
%329 = phi i64* [ %334, %328 ], [ %325, %324 ]
%330 = phi i64* [ %332, %328 ], [ %326, %324 ]
%331 = phi i32 [ %336, %328 ], [ %327, %324 ]
%332 = getelementptr inbounds i64, i64* %330, i64 1
%333 = load i64, i64* %330
%334 = getelementptr inbounds i64, i64* %329, i64 1
%335 = xor i64 %333, -9187201950435737472
store i64 %335, i64* %329
%336 = add nuw nsw i32 %331, 8
%337 = icmp slt i32 %336, %19
br i1 %337, label %328, label %338
338: ; preds = %328, %323, %258
%339 = phi i64* [ %259, %258 ], [ %276, %323 ], [ %332, %328 ]
%340 = add nuw nsw i64 %97, 2
%341 = icmp ult i64 %340, %22
%342 = add i64 %96, 1
br i1 %341, label %95, label %343
343: ; preds = %338, %5
ret void
}