#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 /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
void get_inv_h(int n, double *s, double *y, double *b) {
  double *ytb = (double *)malloc(sizeof(double) * n);
  double *by = (double *)malloc(sizeof(double) * n);
  double *sst = (double *)malloc(sizeof(double) * n * n);
  double *byst = (double *)malloc(sizeof(double) * n * n);
  double *sytb = (double *)malloc(sizeof(double) * n * n);
  double sty = 0.0, ytby = 0.0, alpha = 0.0;
  int i = 0, j = 0, offs = 0;
  for (i = 0; i < n; ++i) {
    sty += s[i] * y[i];
  }
  for (i = offs = 0; i < n; ++i, offs += n) {
    by[i] = 0;
    for (j = 0; j < n; ++j) {
      by[i] += b[offs + j] * y[j];
    }
  }
  for (i = offs = 0; i < n; ++i, offs += n) {
    for (j = 0; j < n; ++j) {
      byst[offs + j] = by[i] * s[j];
    }
  }
  for (i = offs = 0; i < n; i++, offs += n) {
    ytb[i] = 0;
    for (j = 0; j < n; j++) {
      ytb[j] += y[i] * b[offs + j];
    }
  }
  for (i = 0; i < n; ++i) {
    ytby += ytb[i] * y[i];
  }
  for (i = offs = 0; i < n; ++i, offs += n) {
    for (j = 0; j < n; ++j) {
      sytb[offs + j] = s[i] * ytb[j];
    }
  }
  for (i = offs = 0; i < n; ++i, offs += n) {
    for (j = 0; j < n; ++j) {
      sst[offs + j] = s[i] * s[j];
    }
  }
  alpha = 1. / sty + ytby / sty / sty;
  for (i = 0; i < n * n; ++i) {
    b[i] += alpha * sst[i] - (byst[i] + sytb[i]) / sty;
  }
  free(ytb);
  free(by);
  free(sst);
  free(byst);
  free(sytb);
}


x86 assembly (clang, -O0):
<get_inv_h>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
movslq -0x4(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
movslq -0x4(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
movslq -0x4(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1228 <get_inv_h+0x108>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11e2 <get_inv_h+0xc2>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c8 <get_inv_h+0x1a8>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ac <get_inv_h+0x18c>
mov    -0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1259 <get_inv_h+0x139>
jmp    12b1 <get_inv_h+0x191>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1236 <get_inv_h+0x116>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    134b <get_inv_h+0x22b>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    132f <get_inv_h+0x20f>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12e9 <get_inv_h+0x1c9>
jmp    1334 <get_inv_h+0x214>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    12d6 <get_inv_h+0x1b6>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13eb <get_inv_h+0x2cb>
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13cf <get_inv_h+0x2af>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    137c <get_inv_h+0x25c>
jmp    13d4 <get_inv_h+0x2b4>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1359 <get_inv_h+0x239>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1438 <get_inv_h+0x318>
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13f2 <get_inv_h+0x2d2>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14bb <get_inv_h+0x39b>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    149f <get_inv_h+0x37f>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1459 <get_inv_h+0x339>
jmp    14a4 <get_inv_h+0x384>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1446 <get_inv_h+0x326>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    153e <get_inv_h+0x41e>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1522 <get_inv_h+0x402>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14dc <get_inv_h+0x3bc>
jmp    1527 <get_inv_h+0x407>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    14c9 <get_inv_h+0x3a9>
movsd  0xaba(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
divsd  -0x50(%rbp),%xmm1
divsd  -0x50(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
cmp    %ecx,%eax
jge    15ec <get_inv_h+0x4cc>
movsd  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    156a <get_inv_h+0x44a>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_inv_h>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rcx,0x20(%rsp)
mov    %rdx,%rbp
mov    %rsi,%r12
mov    %edi,%ebx
lea    0x0(,%rbx,8),%r13d
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
imul   %ebx,%r13d
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rbx,%rdx
mov    %rax,%r13
test   %edx,%edx
jle    11b3 <get_inv_h+0x93>
mov    %r13,0x18(%rsp)
mov    %edx,%r13d
lea    -0x1(%r13),%r8
mov    %r13d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
mov    %rdx,0x28(%rsp)
jae    11cf <get_inv_h+0xaf>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x20(%rsp),%r10
jmp    122c <get_inv_h+0x10c>
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    0x20(%rsp),%r10
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rdi
jmp    1c76 <get_inv_h+0xb56>
mov    %r13d,%esi
and    $0xfffffffc,%esi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x20(%rsp),%r10
movsd  (%r12,%rdx,8),%xmm1
movsd  0x8(%r12,%rdx,8),%xmm2
mulsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  0x8(%rbp,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r12,%rdx,8),%xmm3
mulsd  0x10(%rbp,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r12,%rdx,8),%xmm0
mulsd  0x18(%rbp,%rdx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    11e0 <get_inv_h+0xc0>
test   %rcx,%rcx
je     1267 <get_inv_h+0x147>
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
lea    (%r12,%rdx,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%rax,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1250 <get_inv_h+0x130>
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    173f <get_inv_h+0x61f>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
lea    0x8(%r10),%rdx
lea    0x0(,%r13,8),%rax
mov    %rax,0x30(%rsp)
xor    %esi,%esi
xor    %edi,%edi
jmp    12b1 <get_inv_h+0x191>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %r13,%rdi
add    0x30(%rsp),%rdx
cmp    %r13,%rsi
je     1329 <get_inv_h+0x209>
movq   $0x0,(%r14,%rsi,8)
xorpd  %xmm1,%xmm1
xor    %eax,%eax
test   %r8,%r8
je     1304 <get_inv_h+0x1e4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rdx,%rax,8),%xmm2
mulsd  0x0(%rbp,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rsi,8)
movsd  (%rdx,%rax,8),%xmm1
mulsd  0x8(%rbp,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r14,%rsi,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    12d0 <get_inv_h+0x1b0>
test   $0x1,%r13b
je     12a0 <get_inv_h+0x180>
lea    (%rax,%rdi,1),%rbx
movsd  (%r10,%rbx,8),%xmm2
mulsd  0x0(%rbp,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rsi,8)
jmp    12a0 <get_inv_h+0x180>
xorpd  %xmm1,%xmm1
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    1743 <get_inv_h+0x623>
mov    %r8,0x70(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x60(%rsp)
lea    (%r12,%r13,8),%rax
mov    %rax,0x68(%rsp)
mov    %r13d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x48(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rdi
lea    0x30(%rdi),%r8
lea    0x8(%rdi),%r9
xor    %r10d,%r10d
xor    %r11d,%r11d
jmp    13cb <get_inv_h+0x2ab>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
add    %r13,%r11
mov    0x30(%rsp),%rax
add    %rax,%r8
add    %rax,%r9
cmp    %r13,%r10
je     1576 <get_inv_h+0x456>
cmp    $0x4,%edx
jae    13e0 <get_inv_h+0x2c0>
xor    %ecx,%ecx
jmp    14f0 <get_inv_h+0x3d0>
nopw   0x0(%rax,%rax,1)
lea    (%r11,%r13,1),%rax
lea    (%rdi,%r11,8),%rcx
lea    (%rdi,%rax,8),%rdx
lea    (%r14,%r10,8),%rax
add    $0x8,%rax
lea    (%r14,%r10,8),%rbx
cmp    %rax,%rcx
setb   %dil
cmp    %rdx,%rbx
setb   %bl
cmp    0x68(%rsp),%rcx
setb   %al
cmp    %r12,%rdx
seta   %dl
test   %bl,%dil
jne    14e2 <get_inv_h+0x3c2>
mov    $0x0,%ecx
and    %dl,%al
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%rdx
jne    14f0 <get_inv_h+0x3d0>
cmpq   $0x0,0x58(%rsp)
je     1564 <get_inv_h+0x444>
movsd  (%r14,%r10,8),%xmm2
unpcklpd %xmm2,%xmm2
mov    0x48(%rsp),%rax
xor    %ecx,%ecx
movupd (%r12,%rcx,8),%xmm3
movupd 0x10(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%r8,%rcx,8)
movupd %xmm4,-0x20(%r8,%rcx,8)
movupd 0x20(%r12,%rcx,8),%xmm3
movupd 0x30(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x10(%r8,%rcx,8)
movupd %xmm4,(%r8,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1450 <get_inv_h+0x330>
testb  $0x1,0x38(%rsp)
je     14d4 <get_inv_h+0x3b4>
movsd  (%r14,%r10,8),%xmm2
unpcklpd %xmm2,%xmm2
movupd (%r12,%rcx,8),%xmm3
movupd 0x10(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
add    %r11,%rcx
movupd %xmm3,(%rdi,%rcx,8)
movupd %xmm4,0x10(%rdi,%rcx,8)
mov    %rsi,%rcx
cmp    %r13,%rsi
je     13b0 <get_inv_h+0x290>
jmp    14f0 <get_inv_h+0x3d0>
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%rdx
xchg   %ax,%ax
mov    %rcx,%rax
test   $0x1,%r13b
je     1515 <get_inv_h+0x3f5>
movsd  (%r14,%r10,8),%xmm2
mulsd  (%r12,%rcx,8),%xmm2
lea    (%rcx,%r11,1),%rax
movsd  %xmm2,(%rdi,%rax,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     13b0 <get_inv_h+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%r10,8),%xmm2
mulsd  (%r12,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r9,%rax,8)
movsd  (%r14,%r10,8),%xmm2
mulsd  0x8(%r12,%rax,8),%xmm2
movsd  %xmm2,(%r9,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1530 <get_inv_h+0x410>
jmp    13b0 <get_inv_h+0x290>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    14a7 <get_inv_h+0x387>
jmp    14d4 <get_inv_h+0x3b4>
test   %edx,%edx
jle    177b <get_inv_h+0x65b>
lea    (%r15,%r13,8),%rax
mov    %rax,0x48(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
mov    0x20(%rsp),%r10
lea    0x10(%r10),%rsi
mov    0x30(%rsp),%r11
and    $0xffffffffffffffe0,%r11
lea    0x8(%r10),%rdx
xor    %edi,%edi
xor    %r9d,%r9d
mov    0x48(%rsp),%r8
jmp    15db <get_inv_h+0x4bb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
add    %r13,%r9
mov    0x30(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdx
cmp    %r13,%rdi
je     1757 <get_inv_h+0x637>
movq   $0x0,(%r15,%rdi,8)
cmpl   $0x4,0x28(%rsp)
jae    1600 <get_inv_h+0x4e0>
xor    %ecx,%ecx
jmp    16c0 <get_inv_h+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r9,%r13,1),%rax
lea    (%r10,%rax,8),%rax
lea    (%r10,%r9,8),%r10
lea    0x8(,%rdi,8),%rbx
add    %rbp,%rbx
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%r15
setb   %bl
cmp    %r8,%rcx
setb   %cl
cmp    %rax,%r15
setb   %al
cmp    %r8,%r10
setb   %r10b
test   %cl,%bl
jne    16b1 <get_inv_h+0x591>
mov    $0x0,%ecx
and    %r10b,%al
mov    0x20(%rsp),%r10
jne    16c0 <get_inv_h+0x5a0>
movsd  0x0(%rbp,%rdi,8),%xmm2
unpcklpd %xmm2,%xmm2
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rax,1),%xmm3
movupd (%rsi,%rax,1),%xmm4
movupd (%r15,%rax,1),%xmm5
movupd 0x10(%r15,%rax,1),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%r15,%rax,1)
movupd %xmm4,0x10(%r15,%rax,1)
add    $0x20,%rax
cmp    %rax,%r11
jne    1660 <get_inv_h+0x540>
mov    0x50(%rsp),%rax
mov    %rax,%rcx
cmp    %r13,%rax
je     15c0 <get_inv_h+0x4a0>
jmp    16c0 <get_inv_h+0x5a0>
xor    %ecx,%ecx
mov    0x20(%rsp),%r10
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rax
test   $0x1,%r13b
je     16ec <get_inv_h+0x5cc>
movsd  0x0(%rbp,%rdi,8),%xmm2
lea    (%rcx,%r9,1),%rax
mulsd  (%r10,%rax,8),%xmm2
addsd  (%r15,%rcx,8),%xmm2
movsd  %xmm2,(%r15,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     15c0 <get_inv_h+0x4a0>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  -0x8(%rdx,%rax,8),%xmm2
addsd  (%r15,%rax,8),%xmm2
movsd  %xmm2,(%r15,%rax,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1700 <get_inv_h+0x5e0>
jmp    15c0 <get_inv_h+0x4a0>
xorpd  %xmm1,%xmm1
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%r13
jmp    1c76 <get_inv_h+0xb56>
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    1743 <get_inv_h+0x623>
mov    %r13d,%ecx
and    $0x3,%ecx
cmpq   $0x3,0x70(%rsp)
mov    0x8(%rsp),%rdi
jae    1785 <get_inv_h+0x665>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    17ec <get_inv_h+0x6cc>
mov    0x20(%rsp),%r10
jmp    1a44 <get_inv_h+0x924>
mov    %r13d,%esi
and    $0xfffffffc,%esi
xorpd  %xmm1,%xmm1
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm2
movsd  0x8(%r15,%rdx,8),%xmm3
mulsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  0x8(%rbp,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%r15,%rdx,8),%xmm4
mulsd  0x10(%rbp,%rdx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%r15,%rdx,8),%xmm1
mulsd  0x18(%rbp,%rdx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    17a0 <get_inv_h+0x680>
test   %rcx,%rcx
je     1827 <get_inv_h+0x707>
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
lea    (%r15,%rdx,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm2
mulsd  (%rax,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1810 <get_inv_h+0x6f0>
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    1a44 <get_inv_h+0x924>
mov    %r13d,%r9d
and    $0xfffffffc,%r9d
mov    0x38(%rsp),%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x50(%rsp)
mov    0x18(%rsp),%rax
lea    0x30(%rax),%rbp
lea    0x8(%rax),%rdi
xor    %esi,%esi
xor    %edx,%edx
jmp    188b <get_inv_h+0x76b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    %r13,%rdx
mov    0x30(%rsp),%rax
add    %rax,%rbp
add    %rax,%rdi
cmp    %r13,%rsi
je     1a53 <get_inv_h+0x933>
cmpl   $0x4,0x28(%rsp)
jae    18a0 <get_inv_h+0x780>
xor    %ecx,%ecx
jmp    19c0 <get_inv_h+0x8a0>
nopl   0x0(%rax)
lea    (%rdx,%r13,1),%rax
mov    0x18(%rsp),%rbx
lea    (%rbx,%rdx,8),%rcx
lea    (%rbx,%rax,8),%rbx
lea    (%r12,%rsi,8),%rax
add    $0x8,%rax
lea    (%r12,%rsi,8),%r10
cmp    %rax,%rcx
setb   %r11b
cmp    %rbx,%r10
setb   %r8b
cmp    0x48(%rsp),%rcx
setb   %al
cmp    %rbx,%r15
setb   %r10b
test   %r8b,%r11b
jne    19b4 <get_inv_h+0x894>
mov    $0x0,%ecx
and    %r10b,%al
mov    0x20(%rsp),%r10
jne    19c0 <get_inv_h+0x8a0>
cmpq   $0x0,0x58(%rsp)
je     1a32 <get_inv_h+0x912>
movsd  (%r12,%rsi,8),%xmm2
unpcklpd %xmm2,%xmm2
mov    0x50(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%rbp,%rcx,8)
movupd %xmm4,-0x20(%rbp,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x10(%rbp,%rcx,8)
movupd %xmm4,0x0(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1920 <get_inv_h+0x800>
testb  $0x1,0x38(%rsp)
je     19a6 <get_inv_h+0x886>
movsd  (%r12,%rsi,8),%xmm2
unpcklpd %xmm2,%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
add    %rdx,%rcx
mov    0x18(%rsp),%rax
movupd %xmm3,(%rax,%rcx,8)
movupd %xmm4,0x10(%rax,%rcx,8)
mov    %r9,%rcx
cmp    %r13,%r9
je     1870 <get_inv_h+0x750>
jmp    19c0 <get_inv_h+0x8a0>
xor    %ecx,%ecx
mov    0x20(%rsp),%r10
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rax
test   $0x1,%r13b
je     19ea <get_inv_h+0x8ca>
movsd  (%r12,%rsi,8),%xmm2
mulsd  (%r15,%rcx,8),%xmm2
lea    (%rcx,%rdx,1),%rax
mov    0x18(%rsp),%rbx
movsd  %xmm2,(%rbx,%rax,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     1870 <get_inv_h+0x750>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rsi,8),%xmm2
mulsd  (%r15,%rax,8),%xmm2
movsd  %xmm2,-0x8(%rdi,%rax,8)
movsd  (%r12,%rsi,8),%xmm2
mulsd  0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1a00 <get_inv_h+0x8e0>
jmp    1870 <get_inv_h+0x750>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1974 <get_inv_h+0x854>
jmp    19a6 <get_inv_h+0x886>
mov    0x10(%rsp),%rbx
mov    0x18(%rsp),%r13
jmp    1c76 <get_inv_h+0xb56>
mov    0x28(%rsp),%rdx
test   %edx,%edx
jle    1743 <get_inv_h+0x623>
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x40(%rsp)
mov    0x38(%rsp),%rax
and    %rax,0x60(%rsp)
mov    %r13,%r9
neg    %r9
mov    0x10(%rsp),%rax
lea    0x30(%rax),%rdi
lea    0x8(%rax),%rbp
xor    %edx,%edx
xor    %esi,%esi
jmp    1aab <get_inv_h+0x98b>
xchg   %ax,%ax
add    $0x1,%rdx
add    %r13,%rsi
mov    0x30(%rsp),%rax
add    %rax,%rdi
add    %rax,%rbp
cmp    %r13,%rdx
je     1c62 <get_inv_h+0xb42>
cmpl   $0x4,0x28(%rsp)
jae    1b30 <get_inv_h+0xa10>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r13b
je     1ade <get_inv_h+0x9be>
movsd  (%r12,%rdx,8),%xmm2
mulsd  (%r12,%rcx,8),%xmm2
lea    (%rcx,%rsi,1),%rax
mov    0x10(%rsp),%rbx
movsd  %xmm2,(%rbx,%rax,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r9,%rcx
je     1a90 <get_inv_h+0x970>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm2
mulsd  (%r12,%rax,8),%xmm2
movsd  %xmm2,-0x8(%rbp,%rax,8)
movsd  (%r12,%rdx,8),%xmm2
mulsd  0x8(%r12,%rax,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1af0 <get_inv_h+0x9d0>
jmp    1a90 <get_inv_h+0x970>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%r13,1),%rax
mov    0x10(%rsp),%rbx
lea    (%rbx,%rsi,8),%rcx
lea    (%rbx,%rax,8),%rbx
lea    (%r12,%rdx,8),%rax
add    $0x8,%rax
lea    (%r12,%rdx,8),%r10
cmp    0x68(%rsp),%rcx
setb   %r11b
cmp    %r12,%rbx
seta   %r8b
cmp    %rax,%rcx
setb   %al
cmp    %rbx,%r10
setb   %r10b
test   %r8b,%r11b
jne    1c4b <get_inv_h+0xb2b>
mov    $0x0,%ecx
and    %r10b,%al
mov    0x20(%rsp),%r10
jne    1ab4 <get_inv_h+0x994>
cmpq   $0x0,0x58(%rsp)
je     1c57 <get_inv_h+0xb37>
movsd  (%r12,%rdx,8),%xmm2
unpcklpd %xmm2,%xmm2
mov    0x60(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r12,%rcx,8),%xmm3
movupd 0x10(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%rdi,%rcx,8)
movupd %xmm4,-0x20(%rdi,%rcx,8)
movupd 0x20(%r12,%rcx,8),%xmm3
movupd 0x30(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x10(%rdi,%rcx,8)
movupd %xmm4,(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1bb0 <get_inv_h+0xa90>
testb  $0x1,0x38(%rsp)
je     1c35 <get_inv_h+0xb15>
movsd  (%r12,%rdx,8),%xmm2
unpcklpd %xmm2,%xmm2
movupd (%r12,%rcx,8),%xmm3
movupd 0x10(%r12,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
add    %rsi,%rcx
mov    0x10(%rsp),%rax
movupd %xmm3,(%rax,%rcx,8)
movupd %xmm4,0x10(%rax,%rcx,8)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %r13,%rax
je     1a90 <get_inv_h+0x970>
jmp    1ab4 <get_inv_h+0x994>
xor    %ecx,%ecx
mov    0x20(%rsp),%r10
jmp    1ab4 <get_inv_h+0x994>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1c03 <get_inv_h+0xae3>
jmp    1c35 <get_inv_h+0xb15>
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%r13
mov    0x28(%rsp),%rdx
imul   %edx,%edx
test   %edx,%edx
je     1cd2 <get_inv_h+0xbb2>
movsd  0x37b(%rip),%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    %edx,%eax
cmp    $0x1,%edx
jne    1d0b <get_inv_h+0xbeb>
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  (%rdi,%rcx,8),%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
divsd  %xmm0,%xmm2
movsd  (%rbx,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm2,%xmm3
addsd  (%r10,%rcx,8),%xmm3
movsd  %xmm3,(%r10,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1ca0 <get_inv_h+0xb80>
mov    %rdi,%rbp
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    (%r10,%rax,8),%rcx
lea    (%rbx,%rax,8),%rdx
lea    (%rdi,%rax,8),%rsi
lea    0x0(,%rax,8),%rbp
add    %r13,%rbp
cmp    %r10,%rdx
seta   %r9b
cmp    %rcx,%rbx
setb   %r11b
cmp    %r10,%rsi
seta   %dl
cmp    %rcx,%rdi
setb   %dil
cmp    %r10,%rbp
seta   %sil
cmp    %rcx,%r13
setb   %r8b
xor    %ecx,%ecx
test   %r11b,%r9b
jne    1dc8 <get_inv_h+0xca8>
and    %dil,%dl
jne    1dd2 <get_inv_h+0xcb2>
and    %r8b,%sil
mov    0x8(%rsp),%rdi
jne    1ca0 <get_inv_h+0xb80>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
xor    %edx,%edx
nopl   0x0(%rax)
movupd (%rbx,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd (%rdi,%rdx,8),%xmm5
movupd 0x0(%r13,%rdx,8),%xmm6
addpd  %xmm5,%xmm6
divpd  %xmm2,%xmm6
subpd  %xmm6,%xmm4
movupd (%r10,%rdx,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r10,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1d80 <get_inv_h+0xc60>
cmp    %rax,%rcx
jne    1ca0 <get_inv_h+0xb80>
jmp    1cd2 <get_inv_h+0xbb2>
mov    0x8(%rsp),%rdi
jmp    1ca0 <get_inv_h+0xb80>
mov    0x8(%rsp),%rdi
jmp    1ca0 <get_inv_h+0xb80>

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

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