#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*/ calc(double *, double *, unsigned int, unsigned int, int,
                        int);
double fabs(double);
int mx_inv(unsigned int n, unsigned int r, double *b, double *a, double eps) {
  for (unsigned k = 0; k < n; k++) {
    unsigned int m = k;
    for (unsigned l = k + 1; l < n; l++) {
      if (fabs(a[l * n + k]) > fabs(a[m * n + k])) {
        m = l;
      }
    }
    if (fabs(a[m * n + k]) < eps) {
      return -1;
    }
    for (unsigned l = 0; l < n; l++) {
      double t = a[k * n + l];
      a[k * n + l] = a[m * n + l];
      a[m * n + l] = t;
    }
    for (unsigned l = 0; l < r; l++) {
      double t = b[k * r + l];
      b[k * r + l] = b[m * r + l];
      b[m * r + l] = t;
    }
    for (unsigned j = k + 1; j < n; j++) {
      calc(a, b, n, r, k, j);
    }
  }
  for (int k = n - 1; k >= 0; k--) {
    for (int j = k - 1; j >= 0; j--) {
      calc(a, b, n, r, k, j);
    }
  }
  for (unsigned k = 0; k < n; k++) {
    if (fabs(a[k * n + k] - 1.0) > eps) {
      double t = 1.0 / a[k * n + k];
      for (unsigned j = 0; j < r; j++) {
        b[k * r + j] *= t;
      }
      a[k * n + k] = 1.0;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<mx_inv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1346 <mx_inv+0x236>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    11bc <mx_inv+0xac>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe8b(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe6b(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    11a9 <mx_inv+0x99>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    11ae <mx_inv+0x9e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114d <mx_inv+0x3d>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe28(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    11f7 <mx_inv+0xe7>
movl   $0xffffffff,-0x4(%rbp)
jmp    148b <mx_inv+0x37b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1276 <mx_inv+0x166>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11fe <mx_inv+0xee>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    12f5 <mx_inv+0x1e5>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    127d <mx_inv+0x16d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1333 <mx_inv+0x223>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x54(%rbp),%r9d
call   1030 <calc@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12fe <mx_inv+0x1ee>
jmp    1338 <mx_inv+0x228>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1132 <mx_inv+0x22>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     13a8 <mx_inv+0x298>
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jl     1395 <mx_inv+0x285>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x58(%rbp),%r8d
mov    -0x5c(%rbp),%r9d
call   1030 <calc@plt>
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1362 <mx_inv+0x252>
jmp    139a <mx_inv+0x28a>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    134f <mx_inv+0x23f>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1484 <mx_inv+0x374>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x60(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc38(%rip),%xmm1
subsd  %xmm1,%xmm0
movaps 0xc1d(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    1471 <mx_inv+0x361>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x60(%rbp),%ecx
mov    %ecx,%ecx
movsd  0xc06(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1454 <mx_inv+0x344>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x6c(%rbp),%ecx
mov    %ecx,%ecx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    141b <mx_inv+0x30b>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x60(%rbp),%ecx
mov    %ecx,%ecx
movsd  0xba4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1476 <mx_inv+0x366>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13af <mx_inv+0x29f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mx_inv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rcx,%r15
mov    %rdx,%r14
mov    %edi,%r13d
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x50(%rsp)
cmp    $0x2,%edi
mov    $0x1,%r9d
mov    $0x1,%r11d
cmovae %edi,%r11d
mov    %esi,0xc(%rsp)
mov    %esi,%r10d
test   %edi,%edi
movsd  %xmm0,0x58(%rsp)
mov    %r10,0x38(%rsp)
je     18bd <mx_inv+0x7ad>
lea    -0x1(%r10),%rax
mov    %rax,0xb0(%rsp)
lea    (%r14,%r10,8),%rax
mov    %rax,0xa0(%rsp)
lea    -0x1(%r11),%rax
mov    %rax,0xb8(%rsp)
lea    (%r15,%r11,8),%rax
mov    %rax,0xa8(%rsp)
lea    -0x2(%r13),%eax
mov    %eax,0x48(%rsp)
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x80(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x78(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rcx,%rax
mov    %rcx,0x88(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x68(%rsp)
mov    %r11,%rcx
neg    %rcx
mov    %rcx,0xc8(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x70(%rsp)
and    %rax,%rdx
mov    %rdx,0x60(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0xc0(%rsp)
movapd 0xdca(%rip),%xmm3
lea    0x0(%r13,%r13,1),%ebp
mov    $0x4,%ebx
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movl   $0x4,0x20(%rsp)
xor    %r12d,%r12d
mov    %ebp,0x4c(%rsp)
mov    %r11,0xd0(%rsp)
jmp    12cc <mx_inv+0x1bc>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%r9d
add    $0x1,%r9d
add    %r13d,0x20(%rsp)
mov    0x18(%rsp),%rax
add    %r13d,%eax
mov    %rax,0x18(%rsp)
mov    0x28(%rsp),%ebx
add    %ebp,%ebx
mov    0x10(%rsp),%rax
add    %ebp,%eax
mov    %rax,0x10(%rsp)
mov    0x30(%rsp),%eax
mov    %eax,%r12d
cmp    %r13d,%eax
movsd  0x58(%rsp),%xmm0
mov    0x38(%rsp),%r10
mov    0xd0(%rsp),%r11
movapd 0xd3e(%rip),%xmm3
mov    0x4c(%rsp),%ebp
je     18bd <mx_inv+0x7ad>
lea    0x1(%r12),%ecx
mov    %r12d,%eax
mov    %ecx,0x30(%rsp)
cmp    %r13d,%ecx
jae    1350 <mx_inv+0x240>
mov    %r12d,%eax
not    %eax
add    %r13d,%eax
mov    %r9d,%ecx
test   $0x1,%al
jne    1300 <mx_inv+0x1f0>
mov    %r12d,%edi
cmp    %r12d,0x48(%rsp)
je     1350 <mx_inv+0x240>
jmp    1810 <mx_inv+0x700>
nopl   0x0(%rax,%rax,1)
mov    %r9d,%eax
imul   %r13d,%eax
add    %r12d,%eax
movsd  (%r15,%rax,8),%xmm2
andpd  %xmm3,%xmm2
mov    %r12d,%eax
imul   %r13d,%eax
add    %r12d,%eax
movsd  (%r15,%rax,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm1,%xmm2
mov    %r12d,%eax
cmova  %r9d,%eax
add    $0x1,%rcx
mov    %eax,%edi
cmp    %r12d,0x48(%rsp)
jne    1810 <mx_inv+0x700>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%ecx
imul   %r13d,%ecx
lea    (%rcx,%r12,1),%edx
movsd  (%r15,%rdx,8),%xmm1
andpd  0xc98(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1b84 <mx_inv+0xa74>
mov    %ebx,0x28(%rsp)
mov    %r12d,%r8d
imul   %r13d,%r8d
cmp    $0x4,%r11d
mov    %r9d,0x40(%rsp)
jae    1530 <mx_inv+0x420>
xor    %esi,%esi
mov    %rsi,%rdi
test   $0x1,%r11b
je     13bc <mx_inv+0x2ac>
add    %esi,%r8d
movsd  (%r15,%r8,8),%xmm0
lea    (%rcx,%rsi,1),%edx
movsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%r8,8)
movsd  %xmm0,(%r15,%rdx,8)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0xc8(%rsp),%rsi
je     1426 <mx_inv+0x316>
mov    0x18(%rsp),%rdx
add    %edi,%edx
add    %edi,%ecx
mov    %r11,%rsi
sub    %rdi,%rsi
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
movsd  (%r15,%rdi,8),%xmm0
mov    %ecx,%ebp
movsd  (%r15,%rbp,8),%xmm1
movsd  %xmm1,(%r15,%rdi,8)
movsd  %xmm0,(%r15,%rbp,8)
lea    0x1(%rdx),%edi
movsd  (%r15,%rdi,8),%xmm0
lea    0x1(%rcx),%ebp
movsd  (%r15,%rbp,8),%xmm1
movsd  %xmm1,(%r15,%rdi,8)
movsd  %xmm0,(%r15,%rbp,8)
add    $0x2,%edx
add    $0x2,%ecx
add    $0xfffffffffffffffe,%rsi
jne    13e0 <mx_inv+0x2d0>
cmpl   $0x0,0xc(%rsp)
je     14e6 <mx_inv+0x3d6>
mov    %r12d,%r8d
mov    0xc(%rsp),%ecx
imul   %ecx,%r8d
imul   %ecx,%eax
cmp    $0x4,%ecx
jae    16a0 <mx_inv+0x590>
xor    %edx,%edx
mov    %rdx,%rsi
test   $0x1,%r10b
je     1478 <mx_inv+0x368>
add    %edx,%r8d
movsd  (%r14,%r8,8),%xmm0
lea    (%rax,%rdx,1),%ecx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%r8,8)
movsd  %xmm0,(%r14,%rcx,8)
mov    %rdx,%rsi
or     $0x1,%rsi
not    %rdx
cmp    0xc0(%rsp),%rdx
je     14e6 <mx_inv+0x3d6>
mov    0x10(%rsp),%rcx
add    %esi,%ecx
add    %esi,%eax
mov    %r10,%rdx
sub    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%esi
movsd  (%r14,%rsi,8),%xmm0
mov    %eax,%edi
movsd  (%r14,%rdi,8),%xmm1
movsd  %xmm1,(%r14,%rsi,8)
movsd  %xmm0,(%r14,%rdi,8)
lea    0x1(%rcx),%esi
movsd  (%r14,%rsi,8),%xmm0
lea    0x1(%rax),%edi
movsd  (%r14,%rdi,8),%xmm1
movsd  %xmm1,(%r14,%rsi,8)
movsd  %xmm0,(%r14,%rdi,8)
add    $0x2,%ecx
add    $0x2,%eax
add    $0xfffffffffffffffe,%rdx
jne    14a0 <mx_inv+0x390>
mov    0x30(%rsp),%eax
mov    %eax,%ebx
cmp    %r13d,%eax
mov    0xc(%rsp),%ebp
jae    1270 <mx_inv+0x160>
nopl   0x0(%rax)
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r13d,%edx
mov    %ebp,%ecx
mov    %r12d,%r8d
mov    %ebx,%r9d
call   1030 <calc@plt>
add    $0x1,%ebx
cmp    %ebx,%r13d
jne    1500 <mx_inv+0x3f0>
jmp    1270 <mx_inv+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%esi
mov    0xb8(%rsp),%rdi
add    %edi,%esi
setb   %dl
mov    %r8d,%esi
add    %edi,%esi
jb     138c <mx_inv+0x27c>
shr    $0x20,%rdi
jne    138c <mx_inv+0x27c>
test   %dl,%dl
jne    138c <mx_inv+0x27c>
mov    $0x0,%esi
test   %rdi,%rdi
jne    138e <mx_inv+0x27e>
mov    %r8d,%esi
lea    (%r15,%rsi,8),%rbp
mov    %ecx,%edi
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rdi,8),%rbx
cmp    %rbx,%rbp
jae    1595 <mx_inv+0x485>
lea    (%rdx,%rsi,8),%rsi
lea    (%r15,%rdi,8),%rdi
cmp    %rsi,%rdi
jb     138c <mx_inv+0x27c>
cmpq   $0x0,0x90(%rsp)
je     1895 <mx_inv+0x785>
mov    0x68(%rsp),%rdi
mov    %ecx,%ebx
mov    0x20(%rsp),%edx
mov    %edx,%ebp
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x4(%rbp),%edx
movups (%r15,%rdx,8),%xmm0
movups 0x10(%r15,%rdx,8),%xmm1
mov    %ebx,%esi
movups (%r15,%rsi,8),%xmm2
movups 0x10(%r15,%rsi,8),%xmm3
movups %xmm2,(%r15,%rdx,8)
movups %xmm3,0x10(%r15,%rdx,8)
movups %xmm0,(%r15,%rsi,8)
movups %xmm1,0x10(%r15,%rsi,8)
mov    %ebp,%edx
movupd (%r15,%rdx,8),%xmm0
movupd 0x10(%r15,%rdx,8),%xmm1
lea    0x4(%rbx),%esi
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
movupd %xmm2,(%r15,%rdx,8)
movupd %xmm3,0x10(%r15,%rdx,8)
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
add    $0x8,%r9
add    $0x8,%ebp
add    $0x8,%ebx
add    $0xfffffffffffffffe,%rdi
jne    15c0 <mx_inv+0x4b0>
testb  $0x1,0x88(%rsp)
01
je     167f <mx_inv+0x56f>
lea    (%r8,%r9,1),%edx
movupd (%r15,%rdx,8),%xmm0
movupd 0x10(%r15,%rdx,8),%xmm1
add    %ecx,%r9d
movupd (%r15,%r9,8),%xmm2
movupd 0x10(%r15,%r9,8),%xmm3
movupd %xmm2,(%r15,%rdx,8)
movupd %xmm3,0x10(%r15,%rdx,8)
movupd %xmm0,(%r15,%r9,8)
movupd %xmm1,0x10(%r15,%r9,8)
mov    0x98(%rsp),%rdx
mov    %rdx,%rsi
cmp    %r11,%rdx
jne    138e <mx_inv+0x27e>
jmp    1426 <mx_inv+0x316>
nopl   0x0(%rax,%rax,1)
mov    %eax,%edx
mov    0xb0(%rsp),%rcx
add    %ecx,%edx
setb   %dl
mov    %r8d,%esi
add    %ecx,%esi
jb     1448 <mx_inv+0x338>
mov    %rcx,%rsi
shr    $0x20,%rsi
jne    1448 <mx_inv+0x338>
test   %dl,%dl
jne    1448 <mx_inv+0x338>
mov    $0x0,%edx
test   %rsi,%rsi
jne    144a <mx_inv+0x33a>
mov    %r8d,%edx
lea    (%r14,%rdx,8),%rdi
mov    %eax,%esi
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rsi,8),%rbp
cmp    %rbp,%rdi
jae    1708 <mx_inv+0x5f8>
lea    (%rcx,%rdx,8),%rdx
lea    (%r14,%rsi,8),%rsi
cmp    %rdx,%rsi
jb     1448 <mx_inv+0x338>
cmpq   $0x0,0x78(%rsp)
je     18ab <mx_inv+0x79b>
mov    0x60(%rsp),%rsi
mov    %eax,%edi
mov    0x28(%rsp),%ecx
mov    %ecx,%ebp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x4(%rbp),%ebx
movups (%r14,%rbx,8),%xmm0
movups 0x10(%r14,%rbx,8),%xmm1
mov    %edi,%ecx
movups (%r14,%rcx,8),%xmm2
movups 0x10(%r14,%rcx,8),%xmm3
movups %xmm2,(%r14,%rbx,8)
movups %xmm3,0x10(%r14,%rbx,8)
movups %xmm0,(%r14,%rcx,8)
movups %xmm1,0x10(%r14,%rcx,8)
mov    %ebp,%ecx
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
lea    0x4(%rdi),%ebx
movupd (%r14,%rbx,8),%xmm2
movupd 0x10(%r14,%rbx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
movupd %xmm0,(%r14,%rbx,8)
movupd %xmm1,0x10(%r14,%rbx,8)
add    $0x8,%rdx
add    $0x8,%ebp
add    $0x8,%edi
add    $0xfffffffffffffffe,%rsi
jne    1730 <mx_inv+0x620>
testb  $0x1,0x70(%rsp)
je     17eb <mx_inv+0x6db>
lea    (%r8,%rdx,1),%ecx
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
add    %eax,%edx
movupd (%r14,%rdx,8),%xmm2
movupd 0x10(%r14,%rdx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
mov    0x80(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r10,%rcx
jne    144a <mx_inv+0x33a>
jmp    14e6 <mx_inv+0x3d6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rcx),%edx
imul   %r13d,%edx
add    %r12d,%edx
mov    %r13d,%esi
imul   %ecx,%esi
add    %r12d,%esi
jmp    1842 <mx_inv+0x732>
cs nopw 0x0(%rax,%rax,1)
nop
add    %ebp,%edx
add    $0x2,%ecx
add    %ebp,%esi
mov    %eax,%edi
cmp    %ecx,%r13d
je     1350 <mx_inv+0x240>
mov    %esi,%eax
movsd  (%r15,%rax,8),%xmm2
andpd  %xmm3,%xmm2
mov    %edi,%eax
imul   %r13d,%eax
add    %r12d,%eax
movsd  (%r15,%rax,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm1,%xmm2
mov    %ecx,%eax
ja     186b <mx_inv+0x75b>
mov    %edi,%eax
mov    %edx,%edi
movsd  (%r15,%rdi,8),%xmm2
andpd  %xmm3,%xmm2
mov    %eax,%edi
imul   %r13d,%edi
add    %r12d,%edi
movsd  (%r15,%rdi,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm1,%xmm2
jbe    1830 <mx_inv+0x720>
lea    0x1(%rcx),%eax
jmp    1830 <mx_inv+0x720>
xor    %r9d,%r9d
testb  $0x1,0x88(%rsp)
01
jne    1644 <mx_inv+0x534>
jmp    167f <mx_inv+0x56f>
xor    %edx,%edx
testb  $0x1,0x70(%rsp)
jne    17b1 <mx_inv+0x6a1>
jmp    17eb <mx_inv+0x6db>
mov    %r13d,%eax
add    $0xffffffff,%eax
mov    0xc(%rsp),%r12d
js     18fe <mx_inv+0x7ee>
mov    %r13d,%ebx
jmp    18d7 <mx_inv+0x7c7>
nop
mov    %ebx,%eax
add    $0xffffffff,%eax
js     18fe <mx_inv+0x7ee>
mov    %ebx,%ebp
mov    %eax,%ebx
add    $0xfffffffe,%ebp
js     18d0 <mx_inv+0x7c0>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r13d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    %ebp,%r9d
call   1030 <calc@plt>
add    $0xffffffff,%ebp
jb     18e0 <mx_inv+0x7d0>
jmp    18d0 <mx_inv+0x7c0>
test   %r13d,%r13d
je     1b80 <mx_inv+0xa70>
mov    %r13d,%r9d
mov    0x38(%rsp),%rdi
lea    -0x1(%rdi),%r10
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x28(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,%rcx
mov    %rax,0x20(%rsp)
and    %rax,0x50(%rsp)
mov    %edi,%ebx
and    $0x3,%ebx
mov    $0x4,%r11d
xor    %esi,%esi
movsd  0x6c0(%rip),%xmm0
movapd 0x6a8(%rip),%xmm1
movsd  0x6b8(%rip),%xmm2
xor    %edx,%edx
movsd  0x58(%rsp),%xmm7
mov    %r9,0x18(%rsp)
mov    %r10,0x10(%rsp)
mov    %rbx,0x30(%rsp)
jmp    19a3 <mx_inv+0x893>
nopl   0x0(%rax)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r15,%r12,8)
add    $0x1,%rdx
add    0xc(%rsp),%r11d
add    %rdi,%rsi
cmp    %r9,%rdx
je     1b80 <mx_inv+0xa70>
mov    %edx,%r12d
imul   %r13d,%r12d
add    %edx,%r12d
movsd  (%r15,%r12,8),%xmm4
movapd %xmm4,%xmm3
addsd  %xmm0,%xmm3
andpd  %xmm1,%xmm3
ucomisd %xmm7,%xmm3
jbe    198e <mx_inv+0x87e>
cmpl   $0x0,0xc(%rsp)
je     1980 <mx_inv+0x870>
movapd %xmm2,%xmm3
divsd  %xmm4,%xmm3
mov    0xc(%rsp),%eax
cmp    $0x4,%eax
jb     1a7e <mx_inv+0x96e>
mov    %edx,%r8d
imul   %eax,%r8d
mov    %r8d,%eax
add    %r10d,%eax
jb     1a7e <mx_inv+0x96e>
mov    %r10,%rax
shr    $0x20,%rax
mov    $0x0,%ecx
jne    1a80 <mx_inv+0x970>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0x40(%rsp)
je     1b2d <mx_inv+0xa1d>
mov    0x50(%rsp),%r9
mov    %r11d,%r10d
xor    %ecx,%ecx
lea    -0x4(%r10),%eax
movupd (%r14,%rax,8),%xmm5
movupd 0x10(%r14,%rax,8),%xmm6
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%r14,%rax,8)
movupd %xmm6,0x10(%r14,%rax,8)
mov    %r10d,%eax
movupd (%r14,%rax,8),%xmm5
movupd 0x10(%r14,%rax,8),%xmm6
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%r14,%rax,8)
movupd %xmm6,0x10(%r14,%rax,8)
add    $0x8,%rcx
add    $0x8,%r10d
add    $0xfffffffffffffffe,%r9
jne    1a20 <mx_inv+0x910>
jmp    1b2f <mx_inv+0xa1f>
xor    %ecx,%ecx
mov    %rcx,%rbp
not    %rbp
add    %rdi,%rbp
test   %rbx,%rbx
je     1abd <mx_inv+0x9ad>
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rcx,1),%ebx
movsd  (%r14,%rbx,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rbx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1aa0 <mx_inv+0x990>
cmp    $0x3,%rbp
mov    0x30(%rsp),%rbx
jb     1980 <mx_inv+0x870>
nopl   0x0(%rax)
lea    (%rsi,%rcx,1),%rax
mov    %eax,%ebp
movsd  (%r14,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rbp,8)
lea    0x1(%rax),%ebp
movsd  (%r14,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rbp,8)
lea    0x2(%rax),%ebp
movsd  (%r14,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rbp,8)
add    $0x3,%eax
movsd  (%r14,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1ad0 <mx_inv+0x9c0>
jmp    1980 <mx_inv+0x870>
xor    %ecx,%ecx
testb  $0x1,0x20(%rsp)
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
je     1b65 <mx_inv+0xa55>
add    %ecx,%r8d
movupd (%r14,%r8,8),%xmm5
movupd 0x10(%r14,%r8,8),%xmm6
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%r14,%r8,8)
movupd %xmm6,0x10(%r14,%r8,8)
mov    0x28(%rsp),%rax
mov    %rax,%rcx
mov    0x38(%rsp),%rdi
cmp    %rdi,%rax
je     1980 <mx_inv+0x870>
jmp    1a80 <mx_inv+0x970>
xor    %eax,%eax
jmp    1b89 <mx_inv+0xa79>
mov    $0xffffffff,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @mx_inv(i32 %0, i32 %1, double* %2, double* %3, double %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca double
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca double
%17 = alloca i32
%18 = alloca double
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double
%24 = alloca i32
store i32 %0, i32* %7
store i32 %1, i32* %8
store double* %2, double** %9
store double* %3, double** %10
store double %4, double* %11
store i32 0, i32* %12
br label %25
25: ; preds = %186, %5
%26 = load i32, i32* %12
%27 = load i32, i32* %7
%28 = icmp ult i32 %26, %27
br i1 %28, label %29, label %189
29: ; preds = %25
%30 = load i32, i32* %12
store i32 %30, i32* %13
%31 = load i32, i32* %12
%32 = add i32 %31, 1
store i32 %32, i32* %14
br label %33
33: ; preds = %62, %29
%34 = load i32, i32* %14
%35 = load i32, i32* %7
%36 = icmp ult i32 %34, %35
br i1 %36, label %37, label %65
37: ; preds = %33
%38 = load double*, double** %10
%39 = load i32, i32* %14
%40 = load i32, i32* %7
%41 = mul i32 %39, %40
%42 = load i32, i32* %12
%43 = add i32 %41, %42
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds double, double* %38, i64 %44
%46 = load double, double* %45
%47 = call double @llvm.fabs.f64(double %46)
%48 = load double*, double** %10
%49 = load i32, i32* %13
%50 = load i32, i32* %7
%51 = mul i32 %49, %50
%52 = load i32, i32* %12
%53 = add i32 %51, %52
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds double, double* %48, i64 %54
%56 = load double, double* %55
%57 = call double @llvm.fabs.f64(double %56)
%58 = fcmp ogt double %47, %57
br i1 %58, label %59, label %61
59: ; preds = %37
%60 = load i32, i32* %14
store i32 %60, i32* %13
br label %61
61: ; preds = %59, %37
br label %62
62: ; preds = %61
%63 = load i32, i32* %14
%64 = add i32 %63, 1
store i32 %64, i32* %14
br label %33
65: ; preds = %33
%66 = load double*, double** %10
%67 = load i32, i32* %13
%68 = load i32, i32* %7
%69 = mul i32 %67, %68
%70 = load i32, i32* %12
%71 = add i32 %69, %70
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds double, double* %66, i64 %72
%74 = load double, double* %73
%75 = call double @llvm.fabs.f64(double %74)
%76 = load double, double* %11
%77 = fcmp olt double %75, %76
br i1 %77, label %78, label %79
78: ; preds = %65
store i32 -1, i32* %6
br label %279
79: ; preds = %65
store i32 0, i32* %15
br label %80
80: ; preds = %120, %79
%81 = load i32, i32* %15
%82 = load i32, i32* %7
%83 = icmp ult i32 %81, %82
br i1 %83, label %84, label %123
84: ; preds = %80
%85 = load double*, double** %10
%86 = load i32, i32* %12
%87 = load i32, i32* %7
%88 = mul i32 %86, %87
%89 = load i32, i32* %15
%90 = add i32 %88, %89
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds double, double* %85, i64 %91
%93 = load double, double* %92
store double %93, double* %16
%94 = load double*, double** %10
%95 = load i32, i32* %13
%96 = load i32, i32* %7
%97 = mul i32 %95, %96
%98 = load i32, i32* %15
%99 = add i32 %97, %98
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds double, double* %94, i64 %100
%102 = load double, double* %101
%103 = load double*, double** %10
%104 = load i32, i32* %12
%105 = load i32, i32* %7
%106 = mul i32 %104, %105
%107 = load i32, i32* %15
%108 = add i32 %106, %107
%109 = zext i32 %108 to i64
%110 = getelementptr inbounds double, double* %103, i64 %109
store double %102, double* %110
%111 = load double, double* %16
%112 = load double*, double** %10
%113 = load i32, i32* %13
%114 = load i32, i32* %7
%115 = mul i32 %113, %114
%116 = load i32, i32* %15
%117 = add i32 %115, %116
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds double, double* %112, i64 %118
store double %111, double* %119
br label %120
120: ; preds = %84
%121 = load i32, i32* %15
%122 = add i32 %121, 1
store i32 %122, i32* %15
br label %80
123: ; preds = %80
store i32 0, i32* %17
br label %124
124: ; preds = %164, %123
%125 = load i32, i32* %17
%126 = load i32, i32* %8
%127 = icmp ult i32 %125, %126
br i1 %127, label %128, label %167
128: ; preds = %124
%129 = load double*, double** %9
%130 = load i32, i32* %12
%131 = load i32, i32* %8
%132 = mul i32 %130, %131
%133 = load i32, i32* %17
%134 = add i32 %132, %133
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds double, double* %129, i64 %135
%137 = load double, double* %136
store double %137, double* %18
%138 = load double*, double** %9
%139 = load i32, i32* %13
%140 = load i32, i32* %8
%141 = mul i32 %139, %140
%142 = load i32, i32* %17
%143 = add i32 %141, %142
%144 = zext i32 %143 to i64
%145 = getelementptr inbounds double, double* %138, i64 %144
%146 = load double, double* %145
%147 = load double*, double** %9
%148 = load i32, i32* %12
%149 = load i32, i32* %8
%150 = mul i32 %148, %149
%151 = load i32, i32* %17
%152 = add i32 %150, %151
%153 = zext i32 %152 to i64
%154 = getelementptr inbounds double, double* %147, i64 %153
store double %146, double* %154
%155 = load double, double* %18
%156 = load double*, double** %9
%157 = load i32, i32* %13
%158 = load i32, i32* %8
%159 = mul i32 %157, %158
%160 = load i32, i32* %17
%161 = add i32 %159, %160
%162 = zext i32 %161 to i64
%163 = getelementptr inbounds double, double* %156, i64 %162
store double %155, double* %163
br label %164
164: ; preds = %128
%165 = load i32, i32* %17
%166 = add i32 %165, 1
store i32 %166, i32* %17
br label %124
167: ; preds = %124
%168 = load i32, i32* %12
%169 = add i32 %168, 1
store i32 %169, i32* %19
br label %170
170: ; preds = %182, %167
%171 = load i32, i32* %19
%172 = load i32, i32* %7
%173 = icmp ult i32 %171, %172
br i1 %173, label %174, label %185
174: ; preds = %170
%175 = load double*, double** %10
%176 = load double*, double** %9
%177 = load i32, i32* %7
%178 = load i32, i32* %8
%179 = load i32, i32* %12
%180 = load i32, i32* %19
%181 = call i32 @calc(double* %175, double* %176, i32 %177, i32 %178, i32 %179, i32 %180)
br label %182
182: ; preds = %174
%183 = load i32, i32* %19
%184 = add i32 %183, 1
store i32 %184, i32* %19
br label %170
185: ; preds = %170
br label %186
186: ; preds = %185
%187 = load i32, i32* %12
%188 = add i32 %187, 1
store i32 %188, i32* %12
br label %25
189: ; preds = %25
%190 = load i32, i32* %7
%191 = sub i32 %190, 1
store i32 %191, i32* %20
br label %192
192: ; preds = %213, %189
%193 = load i32, i32* %20
%194 = icmp sge i32 %193, 0
br i1 %194, label %195, label %216
195: ; preds = %192
%196 = load i32, i32* %20
%197 = sub nsw i32 %196, 1
store i32 %197, i32* %21
br label %198
198: ; preds = %209, %195
%199 = load i32, i32* %21
%200 = icmp sge i32 %199, 0
br i1 %200, label %201, label %212
201: ; preds = %198
%202 = load double*, double** %10
%203 = load double*, double** %9
%204 = load i32, i32* %7
%205 = load i32, i32* %8
%206 = load i32, i32* %20
%207 = load i32, i32* %21
%208 = call i32 @calc(double* %202, double* %203, i32 %204, i32 %205, i32 %206, i32 %207)
br label %209
209: ; preds = %201
%210 = load i32, i32* %21
%211 = add nsw i32 %210, -1
store i32 %211, i32* %21
br label %198
212: ; preds = %198
br label %213
213: ; preds = %212
%214 = load i32, i32* %20
%215 = add nsw i32 %214, -1
store i32 %215, i32* %20
br label %192
216: ; preds = %192
store i32 0, i32* %22
br label %217
217: ; preds = %275, %216
%218 = load i32, i32* %22
%219 = load i32, i32* %7
%220 = icmp ult i32 %218, %219
br i1 %220, label %221, label %278
221: ; preds = %217
%222 = load double*, double** %10
%223 = load i32, i32* %22
%224 = load i32, i32* %7
%225 = mul i32 %223, %224
%226 = load i32, i32* %22
%227 = add i32 %225, %226
%228 = zext i32 %227 to i64
%229 = getelementptr inbounds double, double* %222, i64 %228
%230 = load double, double* %229
%231 = fsub double %230, 1.000000e+00
%232 = call double @llvm.fabs.f64(double %231)
%233 = load double, double* %11
%234 = fcmp ogt double %232, %233
br i1 %234, label %235, label %274
235: ; preds = %221
%236 = load double*, double** %10
%237 = load i32, i32* %22
%238 = load i32, i32* %7
%239 = mul i32 %237, %238
%240 = load i32, i32* %22
%241 = add i32 %239, %240
%242 = zext i32 %241 to i64
%243 = getelementptr inbounds double, double* %236, i64 %242
%244 = load double, double* %243
%245 = fdiv double 1.000000e+00, %244
store double %245, double* %23
store i32 0, i32* %24
br label %246
246: ; preds = %262, %235
%247 = load i32, i32* %24
%248 = load i32, i32* %8
%249 = icmp ult i32 %247, %248
br i1 %249, label %250, label %265
250: ; preds = %246
%251 = load double, double* %23
%252 = load double*, double** %9
%253 = load i32, i32* %22
%254 = load i32, i32* %8
%255 = mul i32 %253, %254
%256 = load i32, i32* %24
%257 = add i32 %255, %256
%258 = zext i32 %257 to i64
%259 = getelementptr inbounds double, double* %252, i64 %258
%260 = load double, double* %259
%261 = fmul double %260, %251
store double %261, double* %259
br label %262
262: ; preds = %250
%263 = load i32, i32* %24
%264 = add i32 %263, 1
store i32 %264, i32* %24
br label %246
265: ; preds = %246
%266 = load double*, double** %10
%267 = load i32, i32* %22
%268 = load i32, i32* %7
%269 = mul i32 %267, %268
%270 = load i32, i32* %22
%271 = add i32 %269, %270
%272 = zext i32 %271 to i64
%273 = getelementptr inbounds double, double* %266, i64 %272
store double 1.000000e+00, double* %273
br label %274
274: ; preds = %265, %221
br label %275
275: ; preds = %274
%276 = load i32, i32* %22
%277 = add i32 %276, 1
store i32 %277, i32* %22
br label %217
278: ; preds = %217
store i32 0, i32* %6
br label %279
279: ; preds = %278, %78
%280 = load i32, i32* %6
ret i32 %280
}

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