#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int abs(int);
double sqrt(double);
void r_mvndu(int *m0, double *w, double *x, double *rhmat, int *ksign,
             int *nsim, double *eps, int *ifail, double *der0) {
  double der, tem, bb, pr, sd;
  double rr[20][20], mu[20], a[20], b[20], rc[20][20], dd[20];
  int i, j, m1, k, m, ii;
  void mvn1(int, double[], double[], double[][20], int, double, double *,
            double *, int *);
  double phi(double);
  m = *m0;
  k = abs(*ksign);
  for (i = 1, ii = 0; i <= m; i++) {
    for (j = 1; j <= m; j++) {
      rr[i][j] = rhmat[ii];
      ii++;
    }
    a[i] = w[i - 1];
    b[i] = x[i - 1];
  }
  if (k < m) {
    for (i = 1; i <= m; i++) {
      tem = rr[i][m];
      rr[i][m] = rr[i][k];
      rr[i][k] = tem;
    }
    for (i = 1; i <= m; i++) {
      tem = rr[m][i];
      rr[m][i] = rr[k][i];
      rr[k][i] = tem;
    }
    tem = a[m];
    a[m] = a[k];
    a[k] = tem;
    tem = b[m];
    b[m] = b[k];
    b[k] = tem;
  }
  m1 = m - 1;
  if ((*ksign) > 0)
    bb = b[m];
  else
    bb = a[m];
  for (i = 1; i <= m1; i++) {
    for (j = 1; j <= m1; j++)
      rr[i][j] -= rr[i][m] * rr[m][j];
    mu[i] = rr[i][m] * bb;
  }
  for (i = 1; i <= m1; i++) {
    dd[i] = sqrt(rr[i][i]);
    a[i] = (a[i] - mu[i]) / dd[i];
    b[i] = (b[i] - mu[i]) / dd[i];
  }
  for (i = 1; i <= m1; i++) {
    for (j = 1; j <= m1; j++)
      rc[i][j] = rr[i][j] / (dd[i] * dd[j]);
  }
  mvn1(m1, a, b, rc, *nsim, *eps, &pr, &sd, ifail);
  der = phi(bb) * pr;
  if (*ksign < 0)
    der = -der;
  *der0 = der;
}


x86 assembly (clang, -O0):
<r_mvndu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c10,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1bf4(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%edi
call   1030 <abs@plt>
mov    %eax,-0x1bf0(%rbp)
movl   $0x1,-0x1be4(%rbp)
movl   $0x0,-0x1bf8(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bf4(%rbp),%eax
jg     1283 <r_mvndu+0x143>
movl   $0x1,-0x1be8(%rbp)
mov    -0x1be8(%rbp),%eax
cmp    -0x1bf4(%rbp),%eax
jg     1225 <r_mvndu+0xe5>
mov    -0x20(%rbp),%rax
movslq -0x1bf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1bf8(%rbp)
mov    -0x1be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be8(%rbp)
jmp    11bc <r_mvndu+0x7c>
mov    -0x10(%rbp),%rax
mov    -0x1be4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0xe20(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
mov    -0x1be4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0xec0(%rbp,%rax,8)
ff ff
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    11a0 <r_mvndu+0x60>
mov    -0x1bf0(%rbp),%eax
cmp    -0x1bf4(%rbp),%eax
jge    14bd <r_mvndu+0x37d>
movl   $0x1,-0x1be4(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bf4(%rbp),%eax
jg     135f <r_mvndu+0x21f>
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    129f <r_mvndu+0x15f>
movl   $0x1,-0x1be4(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bf4(%rbp),%eax
jg     1429 <r_mvndu+0x2e9>
movslq -0x1bf4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1bf0(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1bf4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1bf0(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    1369 <r_mvndu+0x229>
movslq -0x1bf4(%rbp),%rax
movsd  -0xe20(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1bf0(%rbp),%rax
movsd  -0xe20(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1bf4(%rbp),%rax
movsd  %xmm0,-0xe20(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1bf0(%rbp),%rax
movsd  %xmm0,-0xe20(%rbp,%rax,8)
ff ff
movslq -0x1bf4(%rbp),%rax
movsd  -0xec0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1bf0(%rbp),%rax
movsd  -0xec0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1bf4(%rbp),%rax
movsd  %xmm0,-0xec0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1bf0(%rbp),%rax
movsd  %xmm0,-0xec0(%rbp,%rax,8)
ff ff
mov    -0x1bf4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1bec(%rbp)
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jle    14f3 <r_mvndu+0x3b3>
movslq -0x1bf4(%rbp),%rax
movsd  -0xec0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
jmp    1508 <r_mvndu+0x3c8>
movslq -0x1bf4(%rbp),%rax
movsd  -0xe20(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x1be4(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bec(%rbp),%eax
jg     1631 <r_mvndu+0x4f1>
movl   $0x1,-0x1be8(%rbp)
mov    -0x1be8(%rbp),%eax
cmp    -0x1bec(%rbp),%eax
jg     15e4 <r_mvndu+0x4a4>
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1bf4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be8(%rbp)
jmp    152e <r_mvndu+0x3ee>
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1bf4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x48(%rbp),%xmm0
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0xd80(%rbp,%rax,8)
ff ff
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    1512 <r_mvndu+0x3d2>
movl   $0x1,-0x1be4(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bec(%rbp),%eax
jg     171a <r_mvndu+0x5da>
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <sqrt@plt>
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0x1be0(%rbp,%rax,8)
ff ff
movslq -0x1be4(%rbp),%rax
movsd  -0xe20(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
subsd  -0xd80(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
divsd  -0x1be0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0xe20(%rbp,%rax,8)
ff ff
movslq -0x1be4(%rbp),%rax
movsd  -0xec0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
subsd  -0xd80(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
divsd  -0x1be0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1be4(%rbp),%rax
movsd  %xmm0,-0xec0(%rbp,%rax,8)
ff ff
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    163b <r_mvndu+0x4fb>
movl   $0x1,-0x1be4(%rbp)
mov    -0x1be4(%rbp),%eax
cmp    -0x1bec(%rbp),%eax
jg     17eb <r_mvndu+0x6ab>
movl   $0x1,-0x1be8(%rbp)
mov    -0x1be8(%rbp),%eax
cmp    -0x1bec(%rbp),%eax
jg     17d2 <r_mvndu+0x692>
movslq -0x1be4(%rbp),%rcx
lea    -0xce0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1be4(%rbp),%rax
movsd  -0x1be0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x1be8(%rbp),%rax
mulsd  -0x1be0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movslq -0x1be4(%rbp),%rcx
lea    -0x1b40(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1be8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be8(%rbp)
jmp    1740 <r_mvndu+0x600>
jmp    17d7 <r_mvndu+0x697>
mov    -0x1be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1be4(%rbp)
jmp    1724 <r_mvndu+0x5e4>
mov    -0x1bec(%rbp),%edi
lea    -0xe20(%rbp),%rsi
lea    -0xec0(%rbp),%rdx
lea    -0x1b40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    (%rax),%r8d
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
lea    -0x50(%rbp),%r9
lea    -0x58(%rbp),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <mvn1@plt>
movsd  -0x48(%rbp),%xmm0
call   1050 <phi@plt>
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1871 <r_mvndu+0x731>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x1c10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<r_mvndu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1bf8,%rsp
movslq (%rdi),%r14
mov    (%r8),%r11d
mov    %r11d,%ebx
neg    %ebx
cmovs  %r11d,%ebx
mov    %r14d,%r15d
mov    %r14,%r10
test   %r14,%r14
mov    %r14,0x40(%rsp)
mov    %r8,0x58(%rsp)
mov    %r9,0x50(%rsp)
jle    11ce <r_mvndu+0x8e>
mov    %rdx,%rbp
mov    %rcx,0x8(%rsp)
mov    %ebx,0x34(%rsp)
mov    %r10,0x38(%rsp)
mov    %r11d,0x18(%rsp)
lea    0x0(,%r15,8),%rbx
lea    0x118(%rsp),%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
lea    0x78(%rsp),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
cmp    $0x1,%r15d
mov    %r15,0x48(%rsp)
jne    11dc <r_mvndu+0x9c>
xor    %r14d,%r14d
xor    %r13d,%r13d
jmp    1257 <r_mvndu+0x117>
cmp    %r14d,%ebx
jl     148c <r_mvndu+0x34c>
jmp    15f8 <r_mvndu+0x4b8>
lea    -0x1(%r15),%eax
add    $0x1,%rax
mov    %rax,0x28(%rsp)
and    $0xfffffffe,%r15d
mov    %r15,0x20(%rsp)
lea    0x438(%rsp),%rbp
xor    %r14d,%r14d
xor    %r13d,%r13d
mov    %rbx,0x10(%rsp)
mov    0x8(%rsp),%r12
mov    0x28(%rsp),%r15
nop
lea    -0xa0(%rbp),%rdi
movslq %r13d,%rbx
lea    (%r12,%rbx,8),%rsi
mov    0x10(%rsp),%rdx
call   1040 <memcpy@plt>
add    %r15d,%ebx
add    $0x2,%r14
movslq %ebx,%r13
mov    0x10(%rsp),%rbx
lea    (%r12,%r13,8),%rsi
mov    %rbp,%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
add    %r15,%r13
add    $0x140,%rbp
cmp    %r14,0x20(%rsp)
jne    1210 <r_mvndu+0xd0>
mov    0x48(%rsp),%r15
test   $0x1,%r15b
je     1291 <r_mvndu+0x151>
lea    (%r14,%r14,4),%rax
shl    $0x5,%rax
lea    0x2f0(%rsp),%rcx
lea    (%rax,%rcx,1),%rdi
add    $0xa8,%rdi
movslq %r13d,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
mov    0x34(%rsp),%ebx
cmp    %r15d,%ebx
mov    0x40(%rsp),%r14
mov    0x18(%rsp),%r11d
jge    1496 <r_mvndu+0x356>
test   %r15d,%r15d
jle    148c <r_mvndu+0x34c>
mov    %ebx,%eax
lea    0x1(%r15),%r10
mov    $0x1,%edx
cmp    $0x2,%r10d
je     1335 <r_mvndu+0x1f5>
lea    0x390(%rsp),%rsi
mov    %r15d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%r15,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%r15,8)
movsd  %xmm0,(%rsi,%rax,8)
movsd  0xa0(%rsi,%r15,8),%xmm0
movsd  0xa0(%rsi,%rax,8),%xmm1
movsd  %xmm1,0xa0(%rsi,%r15,8)
movsd  %xmm0,0xa0(%rsi,%rax,8)
add    $0x140,%rsi
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
jne    12e0 <r_mvndu+0x1a0>
test   $0x1,%r15b
je     1363 <r_mvndu+0x223>
lea    (%rdx,%rdx,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x2f0,%rdx
movsd  (%rdx,%r15,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%r15,8)
movsd  %xmm0,(%rdx,%rax,8)
cmpl   $0x0,0x38(%rsp)
jle    148c <r_mvndu+0x34c>
lea    -0x1(%r10),%r8
mov    $0x1,%edx
cmp    $0x4,%r8
jb     1506 <r_mvndu+0x3c6>
lea    (%r15,%r15,4),%rsi
shl    $0x5,%rsi
lea    (%rsp,%rsi,1),%rbp
add    $0x2f8,%rbp
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
lea    (%rsp,%rdi,1),%rbx
add    $0x2f0,%rbx
lea    (%rbx,%r10,8),%rbx
cmp    %rbx,%rbp
jae    13d1 <r_mvndu+0x291>
add    %rsp,%rsi
add    $0x2f0,%rsi
lea    (%rsi,%r10,8),%rsi
add    %rsp,%rdi
add    $0x2f8,%rdi
cmp    %rsi,%rdi
jb     1506 <r_mvndu+0x3c6>
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     14a0 <r_mvndu+0x360>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rax,%rax,4),%rsi
shl    $0x5,%rsi
add    %rsp,%rsi
add    $0x2f0,%rsi
lea    (%r15,%r15,4),%rdi
shl    $0x5,%rdi
lea    (%rsp,%rdi,1),%rbx
add    $0x2f0,%rbx
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups (%rsi,%rdi,8),%xmm2
movups 0x10(%rsi,%rdi,8),%xmm3
movups %xmm2,(%rbx,%rdi,8)
movups %xmm3,0x10(%rbx,%rdi,8)
movups %xmm0,(%rsi,%rdi,8)
movups %xmm1,0x10(%rsi,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movupd 0x20(%rsi,%rdi,8),%xmm2
movupd 0x30(%rsi,%rdi,8),%xmm3
movupd %xmm2,0x20(%rbx,%rdi,8)
movupd %xmm3,0x30(%rbx,%rdi,8)
movups %xmm0,0x20(%rsi,%rdi,8)
movups %xmm1,0x30(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1430 <r_mvndu+0x2f0>
jmp    14a5 <r_mvndu+0x365>
mov    %ebx,%eax
mov    %r14,%r10
jmp    15b8 <r_mvndu+0x478>
mov    0x38(%rsp),%r10
jmp    15f8 <r_mvndu+0x4b8>
mov    $0x1,%edi
test   $0x1,%r9b
je     14f9 <r_mvndu+0x3b9>
lea    (%r15,%r15,4),%rsi
shl    $0x5,%rsi
add    %rsp,%rsi
add    $0x2f0,%rsi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x2f0,%rbp
movupd 0x0(%rbp,%rdi,8),%xmm2
movupd 0x10(%rbp,%rdi,8),%xmm3
movupd %xmm2,(%rsi,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
movups %xmm0,0x0(%rbp,%rdi,8)
movups %xmm1,0x10(%rbp,%rdi,8)
cmp    %rdx,%r8
je     15b5 <r_mvndu+0x475>
or     $0x1,%rdx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r10b
jne    1550 <r_mvndu+0x410>
lea    (%r15,%r15,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x2f0,%rdi
movsd  (%rdi,%rdx,8),%xmm0
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x2f0,%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
movsd  %xmm0,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
add    %r10,%rsi
je     15b5 <r_mvndu+0x475>
lea    (%r15,%r15,4),%rsi
shl    $0x5,%rsi
add    %rsp,%rsi
add    $0x2f8,%rsi
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x2f8,%rdi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  -0x8(%rdi,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
movsd  %xmm0,-0x8(%rdi,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1580 <r_mvndu+0x440>
mov    %r15,%r10
movsd  0x110(%rsp,%r10,8),%xmm0
movsd  0x110(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x110(%rsp,%r10,8)
movsd  %xmm0,0x110(%rsp,%rax,8)
movsd  0x70(%rsp,%r10,8),%xmm0
movsd  0x70(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x70(%rsp,%r10,8)
movsd  %xmm0,0x70(%rsp,%rax,8)
test   %r11d,%r11d
lea    0x70(%rsp),%rax
lea    0x110(%rsp),%rcx
cmovg  %rax,%rcx
movsd  (%rcx,%r10,8),%xmm6
cmp    $0x2,%r15d
movsd  %xmm6,0x18(%rsp)
jl     1a39 <r_mvndu+0x8f9>
lea    0x1(%r10),%rax
mov    %rax,0x8(%rsp)
lea    (%r10,%r10,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%rcx
add    $0x2f8,%rcx
lea    -0x8(%rcx,%r15,8),%rax
mov    %rax,0x28(%rsp)
lea    -0x1(%r15),%r13
mov    %r13,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rax
mov    %rax,0x20(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x10(%rsp)
lea    0x3a8(%rsp),%rdi
lea    0x398(%rsp),%rax
mov    $0x1,%edx
movapd 0x97c(%rip),%xmm0
jmp    16bd <r_mvndu+0x57d>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r10,8),%xmm1
mulsd  %xmm6,%xmm1
movsd  %xmm1,0x250(%rsp,%rdx,8)
add    $0x1,%rdx
add    $0xa0,%rdi
add    $0xa0,%rax
cmp    %r15,%rdx
je     1821 <r_mvndu+0x6e1>
lea    (%rdx,%rdx,4),%rbx
shl    $0x5,%rbx
lea    (%rsp,%rbx,1),%r12
add    $0x2f0,%r12
lea    (%r12,%r10,8),%rbp
mov    $0x1,%r8d
cmp    $0x4,%r13
jb     17a0 <r_mvndu+0x660>
lea    (%rsp,%rbx,1),%r14
add    $0x2f8,%r14
lea    (%r12,%r15,8),%r8
mov    0x8(%rsp),%rbx
lea    (%r12,%rbx,8),%rbx
cmp    %rbx,%r14
setb   %r9b
cmp    %r8,%rbp
mov    %r13,%r11
mov    %r10,%r13
setb   %r10b
cmp    0x28(%rsp),%r14
setb   %bl
cmp    %r8,%rcx
setb   %r14b
mov    $0x1,%r8d
test   %r10b,%r9b
mov    %r13,%r10
mov    %r11,%r13
jne    17a0 <r_mvndu+0x660>
mov    $0x1,%r8d
and    %r14b,%bl
jne    17a0 <r_mvndu+0x660>
movsd  0x0(%rbp),%xmm1
unpcklpd %xmm1,%xmm1
xorpd  %xmm0,%xmm1
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rbx,8),%xmm2
movupd 0x10(%rcx,%rbx,8),%xmm3
movupd -0x10(%rdi,%rbx,8),%xmm4
movupd (%rdi,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rdi,%rbx,8)
movupd %xmm3,(%rdi,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1750 <r_mvndu+0x610>
mov    0x20(%rsp),%r8
cmp    %rsi,%r13
je     1690 <r_mvndu+0x550>
nopl   0x0(%rax,%rax,1)
mov    %r8,%rbx
test   $0x1,%r15b
jne    17c9 <r_mvndu+0x689>
movsd  0x0(%rbp),%xmm1
mulsd  -0x8(%rcx,%r8,8),%xmm1
movsd  (%r12,%r8,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%r8,8)
lea    0x1(%r8),%rbx
not    %r8
cmp    0x10(%rsp),%r8
je     1690 <r_mvndu+0x550>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm1
mulsd  -0x8(%rcx,%rbx,8),%xmm1
movsd  -0x8(%rax,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm2,-0x8(%rax,%rbx,8)
movsd  0x0(%rbp),%xmm2
mulsd  (%rcx,%rbx,8),%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r15
jne    17e0 <r_mvndu+0x6a0>
jmp    1690 <r_mvndu+0x550>
cmp    $0x2,%r15d
jl     1a39 <r_mvndu+0x8f9>
lea    0x398(%rsp),%rbx
mov    $0x1,%ebp
xorpd  %xmm3,%xmm3
jmp    1899 <r_mvndu+0x759>
xchg   %ax,%ax
call   1060 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  %xmm0,0x1b0(%rsp,%rbp,8)
movsd  0x110(%rsp,%rbp,8),%xmm1
movsd  0x250(%rsp,%rbp,8),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x110(%rsp,%rbp,8)
movsd  0x70(%rsp,%rbp,8),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%rsp,%rbp,8)
add    $0x1,%rbp
add    $0xa8,%rbx
cmp    %rbp,%r15
je     18a9 <r_mvndu+0x769>
movsd  (%rbx),%xmm0
ucomisd %xmm3,%xmm0
jb     1840 <r_mvndu+0x700>
sqrtsd %xmm0,%xmm0
jmp    1849 <r_mvndu+0x709>
cmp    $0x2,%r15d
jl     1a39 <r_mvndu+0x8f9>
lea    -0x3(%r15),%r9
mov    %r9,%r14
shr    %r14
add    $0x1,%r14
mov    %r13,%r10
and    $0xfffffffffffffffe,%r10
mov    %r13,%r11
or     $0x1,%r11
mov    %r14,%r8
and    $0xfffffffffffffffe,%r8
lea    0x1028(%rsp),%rbp
lea    0x1010(%rsp),%rdi
lea    0x3a8(%rsp),%rax
lea    0x390(%rsp),%rdx
mov    $0x1,%esi
jmp    1928 <r_mvndu+0x7e8>
nopl   (%rax)
add    $0x1,%rsi
add    $0xa0,%rbp
add    $0xa0,%rax
add    $0xa0,%rdx
add    $0xa0,%rdi
cmp    %r15,%rsi
je     1a39 <r_mvndu+0x8f9>
movsd  0x1b0(%rsp,%rsi,8),%xmm0
mov    $0x1,%ecx
cmp    $0x2,%r13
jb     1a10 <r_mvndu+0x8d0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x2,%r9
jae    1960 <r_mvndu+0x820>
xor    %ebx,%ebx
jmp    19b3 <r_mvndu+0x873>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rax,%rbx,8),%xmm2
movupd 0x1b8(%rsp,%rbx,8),%xmm3
mulpd  %xmm1,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,-0x10(%rbp,%rbx,8)
movupd (%rax,%rbx,8),%xmm2
movupd 0x1c8(%rsp,%rbx,8),%xmm3
mulpd  %xmm1,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,0x0(%rbp,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1970 <r_mvndu+0x830>
test   $0x1,%r14b
je     19fd <r_mvndu+0x8bd>
shl    $0x3,%rbx
or     $0x8,%rbx
mov    %rsi,%rcx
shl    $0x5,%rcx
lea    (%rcx,%rcx,4),%r12
lea    (%rsp,%r12,1),%rcx
add    $0x2f0,%rcx
movupd (%rbx,%rcx,1),%xmm2
movupd 0x1b0(%rsp,%rbx,1),%xmm3
mulpd  %xmm3,%xmm1
divpd  %xmm1,%xmm2
lea    (%rsp,%r12,1),%rcx
add    $0xf70,%rcx
movupd %xmm2,(%rbx,%rcx,1)
mov    %r11,%rcx
cmp    %r10,%r13
je     1900 <r_mvndu+0x7c0>
nopl   0x0(%rax)
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x1b0(%rsp,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1a10 <r_mvndu+0x8d0>
jmp    1900 <r_mvndu+0x7c0>
mov    0x1c40(%rsp),%rbx
mov    0x40(%rsp),%rdi
add    $0xffffffff,%edi
mov    0x50(%rsp),%rax
mov    (%rax),%r8d
mov    0x1c30(%rsp),%rax
movsd  (%rax),%xmm0
lea    0x68(%rsp),%rax
lea    0x110(%rsp),%rsi
lea    0x70(%rsp),%rdx
lea    0xf70(%rsp),%rcx
lea    0x60(%rsp),%r9
push   0x1c38(%rsp)
push   %rax
call   1030 <mvn1@plt>
add    $0x10,%rsp
movsd  0x18(%rsp),%xmm0
call   1050 <phi@plt>
mulsd  0x60(%rsp),%xmm0
mov    0x58(%rsp),%rax
cmpl   $0x0,(%rax)
jns    1ab0 <r_mvndu+0x970>
xorpd  0x550(%rip),%xmm0
movsd  %xmm0,(%rbx)
add    $0x1bf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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