void add_radiation_pressure_small_n(struct CARandCtx *ctx, const double *hbar_k,
                                    double hbar_k_nrm, int n, double *f) {
  double directions[3][128];
  double nrms[128] = {0.0};
  double recoil[3] = {0.0};
  int i, j;
  if (0 == n)
    return;
  assert(n <= 128);
  ca_rand_gaussian(ctx, n, 0.0, 1.0, &directions[0][0]);
  ca_rand_gaussian(ctx, n, 0.0, 1.0, &directions[1][0]);
  ca_rand_gaussian(ctx, n, 0.0, 1.0, &directions[2][0]);
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < n; ++j) {
      nrms[j] += ((directions[i][j]) * (directions[i][j]));
    }
  }
  for (j = 0; j < n; ++j) {
    nrms[j] = sqrt(nrms[j]);
  }
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < n; ++j) {
      directions[i][j] /= nrms[j];
    }
  }
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < n; ++j) {
      recoil[i] += directions[i][j];
    }
    recoil[i] *= hbar_k_nrm;
  }
  for (i = 0; i < 3; ++i) {
    f[i] += n * hbar_k[i] + recoil[i];
  }
}


x86 assembly (clang, -O0):
<add_radiation_pressure_small_n>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1060,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
lea    -0x1030(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
lea    -0x1050(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
xor    %eax,%eax
cmp    -0x1c(%rbp),%eax
jne    1195 <add_radiation_pressure_small_n+0x55>
jmp    14df <add_radiation_pressure_small_n+0x39f>
cmpl   $0x80,-0x1c(%rbp)
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
lea    -0xc30(%rbp),%rdx
xorps  %xmm0,%xmm0
movsd  0xe3c(%rip),%xmm1
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
lea    -0xc30(%rbp),%rdx
add    $0x400,%rdx
xorps  %xmm0,%xmm0
movsd  0xe15(%rip),%xmm1
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
lea    -0xc30(%rbp),%rdx
add    $0x800,%rdx
xorps  %xmm0,%xmm0
movsd  0xdee(%rip),%xmm1
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
movl   $0x0,-0x1054(%rbp)
cmpl   $0x3,-0x1054(%rbp)
jge    12d9 <add_radiation_pressure_small_n+0x199>
movl   $0x0,-0x1058(%rbp)
mov    -0x1058(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c0 <add_radiation_pressure_small_n+0x180>
movslq -0x1054(%rbp),%rcx
lea    -0xc30(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x1058(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1054(%rbp),%rcx
lea    -0xc30(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x1058(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x1058(%rbp),%rax
movsd  -0x1030(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1030(%rbp,%rax,8)
ff ff
mov    -0x1058(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1058(%rbp)
jmp    123a <add_radiation_pressure_small_n+0xfa>
jmp    12c5 <add_radiation_pressure_small_n+0x185>
mov    -0x1054(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1054(%rbp)
jmp    1223 <add_radiation_pressure_small_n+0xe3>
movl   $0x0,-0x1058(%rbp)
mov    -0x1058(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132b <add_radiation_pressure_small_n+0x1eb>
movslq -0x1058(%rbp),%rax
movsd  -0x1030(%rbp,%rax,8),%xmm0
call   1050 <sqrt@plt>
movslq -0x1058(%rbp),%rax
movsd  %xmm0,-0x1030(%rbp,%rax,8)
ff ff
mov    -0x1058(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1058(%rbp)
jmp    12e3 <add_radiation_pressure_small_n+0x1a3>
movl   $0x0,-0x1054(%rbp)
cmpl   $0x3,-0x1054(%rbp)
jge    13c2 <add_radiation_pressure_small_n+0x282>
movl   $0x0,-0x1058(%rbp)
mov    -0x1058(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13a9 <add_radiation_pressure_small_n+0x269>
movslq -0x1058(%rbp),%rax
movsd  -0x1030(%rbp,%rax,8),%xmm1
ff ff
movslq -0x1054(%rbp),%rcx
lea    -0xc30(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x1058(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1058(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1058(%rbp)
jmp    134c <add_radiation_pressure_small_n+0x20c>
jmp    13ae <add_radiation_pressure_small_n+0x26e>
mov    -0x1054(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1054(%rbp)
jmp    1335 <add_radiation_pressure_small_n+0x1f5>
movl   $0x0,-0x1054(%rbp)
cmpl   $0x3,-0x1054(%rbp)
jge    1472 <add_radiation_pressure_small_n+0x332>
movl   $0x0,-0x1058(%rbp)
mov    -0x1058(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1440 <add_radiation_pressure_small_n+0x300>
movslq -0x1054(%rbp),%rcx
lea    -0xc30(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x1058(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1054(%rbp),%rax
addsd  -0x1050(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1050(%rbp,%rax,8)
ff ff
mov    -0x1058(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1058(%rbp)
jmp    13e3 <add_radiation_pressure_small_n+0x2a3>
movsd  -0x18(%rbp),%xmm0
movslq -0x1054(%rbp),%rax
mulsd  -0x1050(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1050(%rbp,%rax,8)
ff ff
mov    -0x1054(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1054(%rbp)
jmp    13cc <add_radiation_pressure_small_n+0x28c>
movl   $0x0,-0x1054(%rbp)
cmpl   $0x3,-0x1054(%rbp)
jge    14df <add_radiation_pressure_small_n+0x39f>
cvtsi2sdl -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1054(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x1054(%rbp),%rax
movsd  -0x1050(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1054(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1054(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1054(%rbp)
jmp    147c <add_radiation_pressure_small_n+0x33c>
add    $0x1060,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<add_radiation_pressure_small_n>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1028,%rsp
mov    %rcx,%r14
mov    %edx,%ebp
movsd  %xmm0,(%rsp)
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0x20(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1030 <memset@plt>
test   %ebp,%ebp
je     1975 <add_radiation_pressure_small_n+0x835>
xor    %edi,%edi
cmp    $0x81,%ebp
setl   %dil
xor    %eax,%eax
call   1040 <assert@plt>
movsd  0xe6b(%rip),%xmm1
lea    0x420(%rsp),%rdx
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
mov    %ebp,%esi
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
lea    0x820(%rsp),%rdx
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
mov    %ebp,%esi
movsd  0xe3a(%rip),%xmm1
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
lea    0xc20(%rsp),%rdx
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
mov    %ebp,%esi
movsd  0xe1a(%rip),%xmm1
mov    $0x2,%al
call   1060 <ca_rand_gaussian@plt>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
mov    %ebp,%r15d
cmp    $0x4,%ebp
jae    1204 <add_radiation_pressure_small_n+0xc4>
xor    %eax,%eax
jmp    12e0 <add_radiation_pressure_small_n+0x1a0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15bb <add_radiation_pressure_small_n+0x47b>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movapd 0x420(%rsp,%rcx,8),%xmm0
movapd 0x430(%rsp,%rcx,8),%xmm1
movapd 0x440(%rsp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
mulpd  %xmm2,%xmm2
addpd  0x40(%rsp,%rcx,8),%xmm2
movapd 0x450(%rsp,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
addpd  0x50(%rsp,%rcx,8),%xmm0
movapd %xmm2,0x40(%rsp,%rcx,8)
movapd %xmm0,0x50(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1230 <add_radiation_pressure_small_n+0xf0>
test   $0x1,%dl
je     12d5 <add_radiation_pressure_small_n+0x195>
movapd 0x420(%rsp,%rcx,8),%xmm0
movapd 0x430(%rsp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
cmp    %r15,%rax
je     1302 <add_radiation_pressure_small_n+0x1c2>
nopw   0x0(%rax,%rax,1)
movsd  0x420(%rsp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    12e0 <add_radiation_pressure_small_n+0x1a0>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
cmp    $0x4,%ebp
jae    1316 <add_radiation_pressure_small_n+0x1d6>
xor    %eax,%eax
jmp    13f0 <add_radiation_pressure_small_n+0x2b0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     169a <add_radiation_pressure_small_n+0x55a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   (%rax)
movapd 0x820(%rsp,%rcx,8),%xmm0
movapd 0x830(%rsp,%rcx,8),%xmm1
movapd 0x840(%rsp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
mulpd  %xmm2,%xmm2
addpd  0x40(%rsp,%rcx,8),%xmm2
movapd 0x850(%rsp,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
addpd  0x50(%rsp,%rcx,8),%xmm0
movapd %xmm2,0x40(%rsp,%rcx,8)
movapd %xmm0,0x50(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1340 <add_radiation_pressure_small_n+0x200>
test   $0x1,%dl
je     13e5 <add_radiation_pressure_small_n+0x2a5>
movapd 0x820(%rsp,%rcx,8),%xmm0
movapd 0x830(%rsp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
cmp    %r15,%rax
je     1412 <add_radiation_pressure_small_n+0x2d2>
nopw   0x0(%rax,%rax,1)
movsd  0x820(%rsp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    13f0 <add_radiation_pressure_small_n+0x2b0>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
cmp    $0x4,%ebp
jae    1426 <add_radiation_pressure_small_n+0x2e6>
xor    %eax,%eax
jmp    1500 <add_radiation_pressure_small_n+0x3c0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     170c <add_radiation_pressure_small_n+0x5cc>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   (%rax)
movapd 0xc20(%rsp,%rcx,8),%xmm0
movapd 0xc30(%rsp,%rcx,8),%xmm1
movapd 0xc40(%rsp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
mulpd  %xmm2,%xmm2
addpd  0x40(%rsp,%rcx,8),%xmm2
movapd 0xc50(%rsp,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
addpd  0x50(%rsp,%rcx,8),%xmm0
movapd %xmm2,0x40(%rsp,%rcx,8)
movapd %xmm0,0x50(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1450 <add_radiation_pressure_small_n+0x310>
test   $0x1,%dl
je     14f5 <add_radiation_pressure_small_n+0x3b5>
movapd 0xc20(%rsp,%rcx,8),%xmm0
movapd 0xc30(%rsp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
addpd  0x20(%rsp,%rcx,8),%xmm0
mulpd  %xmm1,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x20(%rsp,%rcx,8)
movapd %xmm1,0x30(%rsp,%rcx,8)
cmp    %r15,%rax
je     1522 <add_radiation_pressure_small_n+0x3e2>
nopw   0x0(%rax,%rax,1)
movsd  0xc20(%rsp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1500 <add_radiation_pressure_small_n+0x3c0>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
lea    -0x1(%r15),%rax
mov    %r15d,%r13d
and    $0x3,%r13d
mov    %rax,0x8(%rsp)
cmp    $0x3,%rax
mov    %r12,0x18(%rsp)
mov    %ebp,0x14(%rsp)
mov    %r14,%rbx
jae    15cb <add_radiation_pressure_small_n+0x48b>
xor    %r12d,%r12d
test   %r13,%r13
mov    %rbx,%r14
je     159a <add_radiation_pressure_small_n+0x45a>
lea    (%rsp,%r12,8),%rbp
add    $0x20,%rbp
xor    %ebx,%ebx
xorpd  %xmm1,%xmm1
jmp    1588 <add_radiation_pressure_small_n+0x448>
nopw   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
je     159a <add_radiation_pressure_small_n+0x45a>
movsd  0x0(%rbp,%rbx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1570 <add_radiation_pressure_small_n+0x430>
sqrtsd %xmm0,%xmm0
jmp    1579 <add_radiation_pressure_small_n+0x439>
mov    0x14(%rsp),%ebp
test   %ebp,%ebp
mov    0x18(%rsp),%r12
jle    1907 <add_radiation_pressure_small_n+0x7c7>
cmp    $0x1,%ebp
jne    16aa <add_radiation_pressure_small_n+0x56a>
xor    %eax,%eax
jmp    1740 <add_radiation_pressure_small_n+0x600>
xor    %ecx,%ecx
test   $0x1,%dl
jne    12a3 <add_radiation_pressure_small_n+0x163>
jmp    12d5 <add_radiation_pressure_small_n+0x195>
mov    %r15d,%r14d
and    $0xfffffffc,%r14d
xor    %r12d,%r12d
xorpd  %xmm1,%xmm1
jmp    15fd <add_radiation_pressure_small_n+0x4bd>
nopl   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x38(%rsp,%r12,8)
add    $0x4,%r12
cmp    %r12,%r14
je     154f <add_radiation_pressure_small_n+0x40f>
movsd  0x20(%rsp,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1610 <add_radiation_pressure_small_n+0x4d0>
sqrtsd %xmm0,%xmm0
jmp    1619 <add_radiation_pressure_small_n+0x4d9>
call   1050 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x20(%rsp,%r12,8)
movsd  0x28(%rsp,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1640 <add_radiation_pressure_small_n+0x500>
sqrtsd %xmm0,%xmm0
jmp    1649 <add_radiation_pressure_small_n+0x509>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1050 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x28(%rsp,%r12,8)
movsd  0x30(%rsp,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1670 <add_radiation_pressure_small_n+0x530>
sqrtsd %xmm0,%xmm0
jmp    1679 <add_radiation_pressure_small_n+0x539>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1050 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x30(%rsp,%r12,8)
movsd  0x38(%rsp,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jb     15e0 <add_radiation_pressure_small_n+0x4a0>
sqrtsd %xmm0,%xmm0
jmp    15e9 <add_radiation_pressure_small_n+0x4a9>
xor    %ecx,%ecx
test   $0x1,%dl
jne    13b3 <add_radiation_pressure_small_n+0x273>
jmp    13e5 <add_radiation_pressure_small_n+0x2a5>
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     171c <add_radiation_pressure_small_n+0x5dc>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movapd 0x420(%rsp,%rdx,8),%xmm0
movapd 0x430(%rsp,%rdx,8),%xmm1
divpd  0x20(%rsp,%rdx,8),%xmm0
divpd  0x30(%rsp,%rdx,8),%xmm1
movapd %xmm0,0x420(%rsp,%rdx,8)
movapd %xmm1,0x430(%rsp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    16d0 <add_radiation_pressure_small_n+0x590>
jmp    171e <add_radiation_pressure_small_n+0x5de>
xor    %ecx,%ecx
test   $0x1,%dl
jne    14c3 <add_radiation_pressure_small_n+0x383>
jmp    14f5 <add_radiation_pressure_small_n+0x3b5>
xor    %edx,%edx
test   $0x1,%cl
je     173b <add_radiation_pressure_small_n+0x5fb>
movapd 0x420(%rsp,%rdx,8),%xmm0
divpd  0x20(%rsp,%rdx,8),%xmm0
movapd %xmm0,0x420(%rsp,%rdx,8)
cmp    %r15,%rax
je     1761 <add_radiation_pressure_small_n+0x621>
movsd  0x420(%rsp,%rax,8),%xmm0
divsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x420(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1740 <add_radiation_pressure_small_n+0x600>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
cmp    $0x1,%ebp
jne    1775 <add_radiation_pressure_small_n+0x635>
xor    %eax,%eax
jmp    1800 <add_radiation_pressure_small_n+0x6c0>
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     17dc <add_radiation_pressure_small_n+0x69c>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movapd 0x820(%rsp,%rdx,8),%xmm0
movapd 0x830(%rsp,%rdx,8),%xmm1
divpd  0x20(%rsp,%rdx,8),%xmm0
divpd  0x30(%rsp,%rdx,8),%xmm1
movapd %xmm0,0x820(%rsp,%rdx,8)
movapd %xmm1,0x830(%rsp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    17a0 <add_radiation_pressure_small_n+0x660>
jmp    17de <add_radiation_pressure_small_n+0x69e>
xor    %edx,%edx
test   $0x1,%cl
je     17fb <add_radiation_pressure_small_n+0x6bb>
movapd 0x820(%rsp,%rdx,8),%xmm0
divpd  0x20(%rsp,%rdx,8),%xmm0
movapd %xmm0,0x820(%rsp,%rdx,8)
cmp    %r15,%rax
je     1821 <add_radiation_pressure_small_n+0x6e1>
movsd  0x820(%rsp,%rax,8),%xmm0
divsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x820(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1800 <add_radiation_pressure_small_n+0x6c0>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
cmp    $0x1,%ebp
jne    1835 <add_radiation_pressure_small_n+0x6f5>
xor    %eax,%eax
jmp    18c0 <add_radiation_pressure_small_n+0x780>
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     189c <add_radiation_pressure_small_n+0x75c>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movapd 0xc20(%rsp,%rdx,8),%xmm0
movapd 0xc30(%rsp,%rdx,8),%xmm1
divpd  0x20(%rsp,%rdx,8),%xmm0
divpd  0x30(%rsp,%rdx,8),%xmm1
movapd %xmm0,0xc20(%rsp,%rdx,8)
movapd %xmm1,0xc30(%rsp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1860 <add_radiation_pressure_small_n+0x720>
jmp    189e <add_radiation_pressure_small_n+0x75e>
xor    %edx,%edx
test   $0x1,%cl
je     18bb <add_radiation_pressure_small_n+0x77b>
movapd 0xc20(%rsp,%rdx,8),%xmm0
divpd  0x20(%rsp,%rdx,8),%xmm0
movapd %xmm0,0xc20(%rsp,%rdx,8)
cmp    %r15,%rax
je     18e1 <add_radiation_pressure_small_n+0x7a1>
movsd  0xc20(%rsp,%rax,8),%xmm0
divsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0xc20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    18c0 <add_radiation_pressure_small_n+0x780>
test   %ebp,%ebp
jle    1907 <add_radiation_pressure_small_n+0x7c7>
mov    %r15d,%eax
and    $0x7,%eax
cmpq   $0x7,0x8(%rsp)
jae    1987 <add_radiation_pressure_small_n+0x847>
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
movsd  (%rsp),%xmm4
jmp    19f1 <add_radiation_pressure_small_n+0x8b1>
movsd  (%rsp),%xmm4
xorpd  %xmm5,%xmm5
mulsd  %xmm4,%xmm5
xorpd  %xmm1,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm1,%xmm0
xorps  %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
movsd  (%r12),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm5,%xmm3
addsd  (%r14),%xmm3
movsd  %xmm3,(%r14)
movsd  0x8(%r12),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
addsd  0x8(%r14),%xmm3
mulsd  %xmm4,%xmm1
movsd  %xmm3,0x8(%r14)
mulsd  0x10(%r12),%xmm2
addsd  %xmm1,%xmm2
addsd  0x10(%r14),%xmm2
movsd  %xmm2,0x10(%r14)
add    $0x1028,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15d,%edx
and    $0xfffffff8,%edx
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
movsd  (%rsp),%xmm4
nopl   0x0(%rax,%rax,1)
addsd  0x420(%rsp,%rcx,8),%xmm5
addsd  0x428(%rsp,%rcx,8),%xmm5
addsd  0x430(%rsp,%rcx,8),%xmm5
addsd  0x438(%rsp,%rcx,8),%xmm5
addsd  0x440(%rsp,%rcx,8),%xmm5
addsd  0x448(%rsp,%rcx,8),%xmm5
addsd  0x450(%rsp,%rcx,8),%xmm5
addsd  0x458(%rsp,%rcx,8),%xmm5
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    19a0 <add_radiation_pressure_small_n+0x860>
test   %rax,%rax
je     1a1e <add_radiation_pressure_small_n+0x8de>
lea    (%rsp,%rcx,8),%rcx
add    $0x420,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rcx,%rdx,8),%xmm5
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1a10 <add_radiation_pressure_small_n+0x8d0>
mulsd  %xmm4,%xmm5
test   %ebp,%ebp
jle    1914 <add_radiation_pressure_small_n+0x7d4>
mov    %r15d,%eax
and    $0x7,%eax
cmpq   $0x7,0x8(%rsp)
jae    1a40 <add_radiation_pressure_small_n+0x900>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1a9d <add_radiation_pressure_small_n+0x95d>
mov    %r15d,%edx
and    $0xfffffff8,%edx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
addsd  0x820(%rsp,%rcx,8),%xmm0
addsd  0x828(%rsp,%rcx,8),%xmm0
addsd  0x830(%rsp,%rcx,8),%xmm0
addsd  0x838(%rsp,%rcx,8),%xmm0
addsd  0x840(%rsp,%rcx,8),%xmm0
addsd  0x848(%rsp,%rcx,8),%xmm0
addsd  0x850(%rsp,%rcx,8),%xmm0
addsd  0x858(%rsp,%rcx,8),%xmm0
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1a4c <add_radiation_pressure_small_n+0x90c>
test   %rax,%rax
je     1abd <add_radiation_pressure_small_n+0x97d>
lea    (%rsp,%rcx,8),%rcx
add    $0x820,%rcx
xor    %edx,%edx
addsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1aaf <add_radiation_pressure_small_n+0x96f>
mulsd  (%rsp),%xmm0
test   %ebp,%ebp
jle    1adc <add_radiation_pressure_small_n+0x99c>
mov    %r15d,%eax
and    $0x7,%eax
cmpq   $0x7,0x8(%rsp)
jae    1ae2 <add_radiation_pressure_small_n+0x9a2>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    1b3d <add_radiation_pressure_small_n+0x9fd>
xorpd  %xmm1,%xmm1
jmp    1b5d <add_radiation_pressure_small_n+0xa1d>
and    $0xfffffff8,%r15d
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
addsd  0xc20(%rsp,%rcx,8),%xmm1
addsd  0xc28(%rsp,%rcx,8),%xmm1
addsd  0xc30(%rsp,%rcx,8),%xmm1
addsd  0xc38(%rsp,%rcx,8),%xmm1
addsd  0xc40(%rsp,%rcx,8),%xmm1
addsd  0xc48(%rsp,%rcx,8),%xmm1
addsd  0xc50(%rsp,%rcx,8),%xmm1
addsd  0xc58(%rsp,%rcx,8),%xmm1
add    $0x8,%rcx
cmp    %rcx,%r15
jne    1aec <add_radiation_pressure_small_n+0x9ac>
test   %rax,%rax
je     1b5d <add_radiation_pressure_small_n+0xa1d>
lea    (%rsp,%rcx,8),%rcx
add    $0xc20,%rcx
xor    %edx,%edx
addsd  (%rcx,%rdx,8),%xmm1
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1b4f <add_radiation_pressure_small_n+0xa0f>
movsd  (%rsp),%xmm4
jmp    1920 <add_radiation_pressure_small_n+0x7e0>

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

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