void set_halo_to_missval(int nx, int ny, double *array, double missval) {
  int i, j;
  for (j = 0; j < ny + 4; j++)
    array[j * (nx + 4) + 0] = missval;
  for (j = 0; j < ny + 4; j++)
    array[j * (nx + 4) + 1] = missval;
  for (j = 0; j < ny + 4; j++)
    array[j * (nx + 4) + nx + 2] = missval;
  for (j = 0; j < ny + 4; j++)
    array[j * (nx + 4) + nx + 3] = missval;
  for (i = 0; i < nx + 4; i++)
    array[0 * (nx + 4) + i] = missval;
  for (i = 0; i < nx + 4; i++)
    array[1 * (nx + 4) + i] = missval;
  for (i = 0; i < nx + 4; i++)
    array[(ny + 2) * (nx + 4) + i] = missval;
  for (i = 0; i < nx + 4; i++)
    array[(ny + 3) * (nx + 4) + i] = missval;
}


x86 assembly (clang, -O0):
<set_halo_to_missval>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1159 <set_halo_to_missval+0x59>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <set_halo_to_missval+0x1a>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    119f <set_halo_to_missval+0x9f>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1160 <set_halo_to_missval+0x60>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    11e8 <set_halo_to_missval+0xe8>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11a6 <set_halo_to_missval+0xa6>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1231 <set_halo_to_missval+0x131>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ef <set_halo_to_missval+0xef>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1274 <set_halo_to_missval+0x174>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
imul   $0x0,%ecx,%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1238 <set_halo_to_missval+0x138>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    12b7 <set_halo_to_missval+0x1b7>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
shl    $0x0,%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    127b <set_halo_to_missval+0x17b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1300 <set_halo_to_missval+0x200>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12be <set_halo_to_missval+0x1be>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1349 <set_halo_to_missval+0x249>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x3,%ecx
mov    -0x4(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1307 <set_halo_to_missval+0x207>
pop    %rbp
ret

x86 assembly (clang, -O2):
<set_halo_to_missval>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    $0xfffffffd,%esi
jl     132e <set_halo_to_missval+0x22e>
lea    0x4(%rsi),%eax
lea    0x4(%rdi),%r9d
cmp    $0x2,%eax
mov    $0x1,%r10d
cmovge %eax,%r10d
movslq %r9d,%r14
lea    -0x1(%r10),%r8
mov    %r10d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    113c <set_halo_to_missval+0x3c>
xor    %ebp,%ebp
jmp    1192 <set_halo_to_missval+0x92>
mov    %r10d,%r11d
and    $0x7ffffffc,%r11d
mov    %r14,%r15
shl    $0x4,%r15
mov    %r14,%rbx
shl    $0x5,%rbx
lea    0x0(,%r14,8),%rax
lea    (%rax,%rax,2),%r12
xor    %ebp,%ebp
mov    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,(%rax)
movsd  %xmm0,(%rax,%r14,8)
movsd  %xmm0,(%rax,%r15,1)
movsd  %xmm0,(%rax,%r12,1)
add    $0x4,%rbp
add    %rbx,%rax
cmp    %rbp,%r11
jne    1170 <set_halo_to_missval+0x70>
test   %rcx,%rcx
je     11bd <set_halo_to_missval+0xbd>
imul   %r14,%rbp
lea    (%rdx,%rbp,8),%rax
lea    0x0(,%r14,8),%rbp
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rax)
add    %rbp,%rax
add    $0xffffffffffffffff,%rcx
jne    11b0 <set_halo_to_missval+0xb0>
cmp    $0xfffffffd,%esi
jl     132e <set_halo_to_missval+0x22e>
mov    %r10d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    11d6 <set_halo_to_missval+0xd6>
xor    %ebp,%ebp
jmp    1232 <set_halo_to_missval+0x132>
mov    %r10d,%r11d
and    $0x7ffffffc,%r11d
mov    %r14,%r15
shl    $0x4,%r15
lea    0x8(%rdx),%rax
mov    %r14,%rbx
shl    $0x5,%rbx
lea    0x0(,%r14,8),%rbp
lea    0x0(,%rbp,2),%r12
add    %rbp,%r12
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rax)
movsd  %xmm0,(%rax,%r14,8)
movsd  %xmm0,(%rax,%r15,1)
movsd  %xmm0,(%rax,%r12,1)
add    $0x4,%rbp
add    %rbx,%rax
cmp    %rbp,%r11
jne    1210 <set_halo_to_missval+0x110>
test   %rcx,%rcx
je     125d <set_halo_to_missval+0x15d>
imul   %r14,%rbp
lea    (%rdx,%rbp,8),%rax
add    $0x8,%rax
shl    $0x3,%r14
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rax)
add    %r14,%rax
add    $0xffffffffffffffff,%rcx
jne    1250 <set_halo_to_missval+0x150>
cmp    $0xfffffffd,%esi
jl     132e <set_halo_to_missval+0x22e>
mov    %r10d,%r15d
and    $0x3,%r15d
cmp    $0x3,%r8
jae    1278 <set_halo_to_missval+0x178>
xor    %r12d,%r12d
jmp    12e4 <set_halo_to_missval+0x1e4>
mov    %r10d,%r11d
and    $0x7ffffffc,%r11d
lea    (%rdi,%rdi,2),%ebx
add    $0xa,%ebx
lea    0x10(,%rdi,4),%r14d
lea    (%rdi,%rdi,1),%ebp
add    $0x6,%ebp
lea    0xe(,%rdi,4),%eax
lea    0x2(%rdi),%ecx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rcx
movsd  %xmm0,(%rdx,%rcx,8)
movslq %ebp,%rbp
movsd  %xmm0,(%rdx,%rbp,8)
movslq %ebx,%rbx
movsd  %xmm0,(%rdx,%rbx,8)
cltq
movsd  %xmm0,(%rdx,%rax,8)
add    $0x4,%r12
add    %r14d,%ebx
add    %r14d,%ebp
add    %r14d,%eax
add    %r14d,%ecx
cmp    %r12,%r11
jne    12b0 <set_halo_to_missval+0x1b0>
test   %r15,%r15
je     1310 <set_halo_to_missval+0x210>
imul   %r9d,%r12d
lea    (%rdi,%r12,1),%eax
add    $0x2,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cltq
movsd  %xmm0,(%rdx,%rax,8)
add    %r9d,%eax
add    $0xffffffffffffffff,%r15
jne    1300 <set_halo_to_missval+0x200>
cmp    $0xfffffffc,%esi
jle    132e <set_halo_to_missval+0x22e>
mov    %r10d,%r11d
and    $0x3,%r11d
cmp    $0x3,%r8
jae    1593 <set_halo_to_missval+0x493>
xor    %r14d,%r14d
jmp    15f4 <set_halo_to_missval+0x4f4>
lea    0x4(%rdi),%r9d
cmp    $0xfffffffd,%edi
jl     179e <set_halo_to_missval+0x69e>
cmp    $0x2,%r9d
mov    $0x1,%r10d
cmovge %r9d,%r10d
cmp    $0x4,%r10d
jae    1356 <set_halo_to_missval+0x256>
xor    %eax,%eax
jmp    1450 <set_halo_to_missval+0x350>
mov    %r10d,%eax
and    $0x7ffffffc,%eax
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
lea    -0x4(%rax),%rbx
mov    %rbx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%ebp
and    $0x7,%ebp
cmp    $0x1c,%rbx
jae    1385 <set_halo_to_missval+0x285>
xor    %ebx,%ebx
jmp    1411 <set_halo_to_missval+0x311>
movabs $0x7ffffffffffffffc,%rbx
ff ff 7f
add    $0xfffffffffffffffc,%rbx
and    %rbx,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups %xmm1,(%rdx,%rbx,8)
movups %xmm1,0x10(%rdx,%rbx,8)
movups %xmm1,0x20(%rdx,%rbx,8)
movups %xmm1,0x30(%rdx,%rbx,8)
movups %xmm1,0x40(%rdx,%rbx,8)
movups %xmm1,0x50(%rdx,%rbx,8)
movups %xmm1,0x60(%rdx,%rbx,8)
movups %xmm1,0x70(%rdx,%rbx,8)
movups %xmm1,0x80(%rdx,%rbx,8)
movups %xmm1,0x90(%rdx,%rbx,8)
movups %xmm1,0xa0(%rdx,%rbx,8)
movups %xmm1,0xb0(%rdx,%rbx,8)
movups %xmm1,0xc0(%rdx,%rbx,8)
movups %xmm1,0xd0(%rdx,%rbx,8)
movups %xmm1,0xe0(%rdx,%rbx,8)
movups %xmm1,0xf0(%rdx,%rbx,8)
add    $0x20,%rbx
add    $0xfffffffffffffff8,%rcx
jne    13a0 <set_halo_to_missval+0x2a0>
test   %rbp,%rbp
je     1442 <set_halo_to_missval+0x342>
lea    (%rdx,%rbx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm1,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    1430 <set_halo_to_missval+0x330>
cmp    %r10,%rax
je     145e <set_halo_to_missval+0x35e>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1450 <set_halo_to_missval+0x350>
cmp    $0xfffffffd,%edi
jl     179e <set_halo_to_missval+0x69e>
movslq %r9d,%r8
cmp    $0x4,%r10d
jae    1477 <set_halo_to_missval+0x377>
xor    %eax,%eax
jmp    1527 <set_halo_to_missval+0x427>
mov    %r10d,%eax
and    $0x7ffffffc,%eax
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
lea    -0x4(%rax),%rbx
mov    %rbx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r11d
and    $0x3,%r11d
cmp    $0xc,%rbx
jae    14a5 <set_halo_to_missval+0x3a5>
xor    %ebx,%ebx
jmp    14f2 <set_halo_to_missval+0x3f2>
and    $0xfffffffffffffffc,%rcx
lea    (%rdx,%r8,8),%rbp
add    $0x70,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm1,-0x70(%rbp,%rbx,8)
movups %xmm1,-0x60(%rbp,%rbx,8)
movups %xmm1,-0x50(%rbp,%rbx,8)
movups %xmm1,-0x40(%rbp,%rbx,8)
movups %xmm1,-0x30(%rbp,%rbx,8)
movups %xmm1,-0x20(%rbp,%rbx,8)
movups %xmm1,-0x10(%rbp,%rbx,8)
movups %xmm1,0x0(%rbp,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rcx
jne    14c0 <set_halo_to_missval+0x3c0>
test   %r11,%r11
je     1522 <set_halo_to_missval+0x422>
add    %r8,%rbx
lea    (%rdx,%rbx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups %xmm1,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r11
jne    1510 <set_halo_to_missval+0x410>
cmp    %r10,%rax
je     153e <set_halo_to_missval+0x43e>
lea    (%rdx,%r8,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1530 <set_halo_to_missval+0x430>
cmp    $0xfffffffd,%edi
jl     179e <set_halo_to_missval+0x69e>
lea    0x2(%rsi),%eax
imul   %r9d,%eax
movslq %eax,%r8
cmp    $0x4,%r10d
jae    155e <set_halo_to_missval+0x45e>
xor    %eax,%eax
jmp    16a7 <set_halo_to_missval+0x5a7>
mov    %r10d,%eax
and    $0x7ffffffc,%eax
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
lea    -0x4(%rax),%rbx
mov    %rbx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r11d
and    $0x3,%r11d
cmp    $0xc,%rbx
jae    1625 <set_halo_to_missval+0x525>
xor    %ebx,%ebx
jmp    1672 <set_halo_to_missval+0x572>
and    $0x7ffffffc,%r10d
lea    (%rdi,%rdi,2),%ebx
add    $0xb,%ebx
lea    0x10(,%rdi,4),%r8d
lea    (%rdi,%rdi,1),%ebp
add    $0x7,%ebp
lea    0xf(,%rdi,4),%eax
lea    0x3(%rdi),%ecx
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movsd  %xmm0,(%rdx,%rcx,8)
movslq %ebp,%rbp
movsd  %xmm0,(%rdx,%rbp,8)
movslq %ebx,%rbx
movsd  %xmm0,(%rdx,%rbx,8)
cltq
movsd  %xmm0,(%rdx,%rax,8)
add    $0x4,%r14
add    %r8d,%ebx
add    %r8d,%ebp
add    %r8d,%eax
add    %r8d,%ecx
cmp    %r14,%r10
jne    15c0 <set_halo_to_missval+0x4c0>
test   %r11,%r11
je     1332 <set_halo_to_missval+0x232>
imul   %r9d,%r14d
lea    (%rdi,%r14,1),%eax
add    $0x3,%eax
nopl   0x0(%rax,%rax,1)
cltq
movsd  %xmm0,(%rdx,%rax,8)
add    %r9d,%eax
add    $0xffffffffffffffff,%r11
jne    1610 <set_halo_to_missval+0x510>
jmp    1332 <set_halo_to_missval+0x232>
and    $0xfffffffffffffffc,%rcx
lea    (%rdx,%r8,8),%rbp
add    $0x70,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm1,-0x70(%rbp,%rbx,8)
movups %xmm1,-0x60(%rbp,%rbx,8)
movups %xmm1,-0x50(%rbp,%rbx,8)
movups %xmm1,-0x40(%rbp,%rbx,8)
movups %xmm1,-0x30(%rbp,%rbx,8)
movups %xmm1,-0x20(%rbp,%rbx,8)
movups %xmm1,-0x10(%rbp,%rbx,8)
movups %xmm1,0x0(%rbp,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1640 <set_halo_to_missval+0x540>
test   %r11,%r11
je     16a2 <set_halo_to_missval+0x5a2>
add    %r8,%rbx
lea    (%rdx,%rbx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups %xmm1,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r11
jne    1690 <set_halo_to_missval+0x590>
cmp    %r10,%rax
je     16be <set_halo_to_missval+0x5be>
lea    (%rdx,%r8,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    16b0 <set_halo_to_missval+0x5b0>
cmp    $0xfffffffd,%edi
jl     179e <set_halo_to_missval+0x69e>
add    $0x3,%esi
imul   %r9d,%esi
movslq %esi,%rsi
cmp    $0x4,%r10d
jae    16de <set_halo_to_missval+0x5de>
xor    %eax,%eax
jmp    1787 <set_halo_to_missval+0x687>
mov    %r10d,%eax
and    $0x7ffffffc,%eax
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
lea    -0x4(%rax),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rbp
jae    170a <set_halo_to_missval+0x60a>
xor    %ebp,%ebp
jmp    1751 <set_halo_to_missval+0x651>
and    $0xfffffffffffffffc,%rdi
lea    (%rdx,%rsi,8),%rbx
add    $0x70,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups %xmm1,-0x70(%rbx,%rbp,8)
movups %xmm1,-0x60(%rbx,%rbp,8)
movups %xmm1,-0x50(%rbx,%rbp,8)
movups %xmm1,-0x40(%rbx,%rbp,8)
movups %xmm1,-0x30(%rbx,%rbp,8)
movups %xmm1,-0x20(%rbx,%rbp,8)
movups %xmm1,-0x10(%rbx,%rbp,8)
movups %xmm1,(%rbx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1720 <set_halo_to_missval+0x620>
test   %rcx,%rcx
je     1782 <set_halo_to_missval+0x682>
add    %rsi,%rbp
lea    (%rdx,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups %xmm1,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1770 <set_halo_to_missval+0x670>
cmp    %r10,%rax
je     179e <set_halo_to_missval+0x69e>
lea    (%rdx,%rsi,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1790 <set_halo_to_missval+0x690>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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