#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 */
scalar_t__ fabs(double);
double sqrt(double);
void mytred2(double **a, const int n, double *d, double *e) {
  int l, k, j, i;
  double scale, hh, h, g, f;
  for (i = n; i > 1; i--) {
    l = i - 1;
    h = 0.0;
    scale = 0.0;
    if (l > 1) {
      for (k = 1; k <= l; k++)
        scale += fabs(a[k - 1][i - 1]);
      if (scale == 0.0)
        e[i - 1] = a[l - 1][i - 1];
      else {
        for (k = 1; k <= l; k++) {
          a[k - 1][i - 1] /= scale;
          h += a[k - 1][i - 1] * a[k - 1][i - 1];
        }
        f = a[l - 1][i - 1];
        g = ((f > 0) ? -sqrt(h) : sqrt(h));
        e[i - 1] = scale * g;
        h -= f * g;
        a[l - 1][i - 1] = f - g;
        f = 0.0;
        for (j = 1; j <= l; j++) {
          a[i - 1][j - 1] = a[j - 1][i - 1] / h;
          g = 0.0;
          for (k = 1; k <= j; k++)
            g += a[k - 1][j - 1] * a[k - 1][i - 1];
          for (k = j + 1; k <= l; k++)
            g += a[j - 1][k - 1] * a[k - 1][i - 1];
          e[j - 1] = g / h;
          f += e[j - 1] * a[j - 1][i - 1];
        }
        hh = f / (h + h);
        for (j = 1; j <= l; j++) {
          f = a[j - 1][i - 1];
          g = e[j - 1] - hh * f;
          e[j - 1] = g;
          for (k = 1; k <= j; k++)
            a[k - 1][j - 1] -= (f * e[k - 1] + g * a[k - 1][i - 1]);
        }
      }
    } else
      e[i - 1] = a[l - 1][i - 1];
    d[i - 1] = h;
  }
  d[0] = 0.0;
  e[0] = 0.0;
  for (i = 1; i <= n; i++) {
    l = i - 1;
    if (d[i - 1] != 0.0) {
      for (j = 1; j <= l; j++) {
        g = 0.0;
        for (k = 1; k <= l; k++)
          g += a[k - 1][i - 1] * a[j - 1][k - 1];
        for (k = 1; k <= l; k++)
          a[j - 1][k - 1] -= g * a[i - 1][k - 1];
      }
    }
    d[i - 1] = a[i - 1][i - 1];
    a[i - 1][i - 1] = 1.0;
    for (j = 1; j <= l; j++)
      a[i - 1][j - 1] = a[j - 1][i - 1] = 0.0;
  }
}


x86 assembly (clang, -O0):
<mytred2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jle    16f8 <mytred2+0x5d8>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x1,-0x24(%rbp)
jle    16a2 <mytred2+0x582>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11be <mytred2+0x9e>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1171 <mytred2+0x51>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    120c <mytred2+0xec>
jp     120c <mytred2+0xec>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    169d <mytred2+0x57d>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12aa <mytred2+0x18a>
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1213 <mytred2+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    130b <mytred2+0x1eb>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    131a <mytred2+0x1fa>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1553 <mytred2+0x433>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1473 <mytred2+0x353>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1409 <mytred2+0x2e9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14e6 <mytred2+0x3c6>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    147c <mytred2+0x35c>
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ab <mytred2+0x28b>
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1698 <mytred2+0x578>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1685 <mytred2+0x565>
movsd  -0x58(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1600 <mytred2+0x4e0>
jmp    168a <mytred2+0x56a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1572 <mytred2+0x452>
jmp    169d <mytred2+0x57d>
jmp    16d3 <mytred2+0x5b3>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    113d <mytred2+0x1d>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1950 <mytred2+0x830>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1754 <mytred2+0x634>
jp     1754 <mytred2+0x634>
jmp    1880 <mytred2+0x760>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     187b <mytred2+0x75b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     17e0 <mytred2+0x6c0>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1776 <mytred2+0x656>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1868 <mytred2+0x748>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17e7 <mytred2+0x6c7>
jmp    186d <mytred2+0x74d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    175b <mytred2+0x63b>
jmp    1880 <mytred2+0x760>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x72d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     193d <mytred2+0x81d>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18df <mytred2+0x7bf>
jmp    1942 <mytred2+0x822>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1715 <mytred2+0x5f5>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mytred2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r12
mov    %rdx,0x10(%rsp)
mov    %rdi,%rbx
mov    %rsi,0x8(%rsp)
cmp    $0x2,%esi
jl     14eb <mytred2+0x3cb>
mov    0x8(%rsp),%r13d
jmp    117d <mytred2+0x5d>
xchg   %ax,%ax
mov    -0x10(%rbx,%r13,8),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%r12,%r14,8)
xorpd  %xmm5,%xmm5
mov    0x10(%rsp),%rax
movsd  %xmm5,(%rax,%r14,8)
cmp    $0x2,%r13
mov    %r14,%r13
jle    14eb <mytred2+0x3cb>
lea    -0x1(%r13),%r14
cmp    $0x2,%r13
je     14cf <mytred2+0x3af>
xorps  %xmm4,%xmm4
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm4,0x18(%rsp)
mov    -0x8(%rbx,%rbp,8),%rax
movsd  (%rax,%r14,8),%xmm0
call   1030 <fabs@plt>
movsd  0x18(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rbp
cmp    %rbp,%r13
jne    11a0 <mytred2+0x80>
ucomisd 0xe37(%rip),%xmm4
jne    11e1 <mytred2+0xc1>
jnp    1150 <mytred2+0x30>
xorpd  %xmm5,%xmm5
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rbx,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rcx,%r14,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rax
cmp    %rax,%r13
jne    11f0 <mytred2+0xd0>
mov    -0x10(%rbx,%r13,8),%rax
movsd  (%rax,%r14,8),%xmm6
ucomisd 0xde7(%rip),%xmm5
jb     1234 <mytred2+0x114>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    1261 <mytred2+0x141>
movapd %xmm5,%xmm0
movsd  %xmm5,0x28(%rsp)
movsd  %xmm4,0x18(%rsp)
movsd  %xmm6,0x20(%rsp)
call   1040 <sqrt@plt>
movsd  0x20(%rsp),%xmm6
movsd  0x18(%rsp),%xmm4
movsd  0x28(%rsp),%xmm5
movapd %xmm0,%xmm2
xorpd  0xd93(%rip),%xmm2
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
cmpltsd %xmm6,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r12,%r14,8)
movapd %xmm6,%xmm0
mulsd  %xmm3,%xmm0
subsd  %xmm0,%xmm5
subsd  %xmm3,%xmm6
mov    -0x10(%rbx,%r13,8),%rax
movsd  %xmm6,(%rax,%r14,8)
mov    (%rbx,%r14,8),%r8
mov    $0x2,%r9d
mov    $0x1,%ecx
xor    %r10d,%r10d
jmp    12e9 <mytred2+0x1c9>
nop
divsd  %xmm5,%xmm0
movsd  %xmm0,-0x8(%r12,%rcx,8)
mulsd  (%rdi,%r14,8),%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%r9
add    $0x1,%r10
mov    %rax,%rcx
cmp    %r13,%rax
je     13c0 <mytred2+0x2a0>
mov    -0x8(%rbx,%rcx,8),%rdi
movsd  (%rdi,%r14,8),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,-0x8(%r8,%rcx,8)
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
test   %r10,%r10
je     135c <mytred2+0x23c>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    -0x8(%rbx,%rax,8),%rbp
mov    (%rbx,%rax,8),%rdx
movsd  -0x8(%rbp,%rcx,8),%xmm2
mulsd  0x0(%rbp,%r14,8),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  (%rdx,%r14,8),%xmm0
addsd  %xmm2,%xmm0
lea    (%rsi,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1320 <mytred2+0x200>
test   $0x1,%cl
je     1376 <mytred2+0x256>
mov    -0x8(%rbx,%rax,8),%rax
movsd  -0x8(%rax,%rcx,8),%xmm2
mulsd  (%rax,%r14,8),%xmm2
addsd  %xmm2,%xmm0
lea    0x1(%rcx),%rax
cmp    %r13,%rax
jge    12c0 <mytred2+0x1a0>
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rsi,8),%xmm2
mov    -0x8(%rbx,%rsi,8),%rdx
mulsd  (%rdx,%r14,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rsi
cmp    %r13,%rsi
jl     1390 <mytred2+0x270>
jmp    12c0 <mytred2+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
xorpd  0xc30(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    13f1 <mytred2+0x2d1>
nopl   (%rax)
add    $0x1,%rax
add    $0x1,%rcx
cmp    %r13,%rax
je     1165 <mytred2+0x45>
mov    -0x8(%rbx,%rax,8),%rdx
movsd  (%rdx,%r14,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  -0x8(%r12,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r12,%rax,8)
mov    $0x1,%edx
test   %rcx,%rcx
je     149c <mytred2+0x37c>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edx
nop
mov    -0x8(%rbx,%rdx,8),%rdi
movsd  (%rdi,%r14,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  -0x8(%r12,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  -0x8(%rdi,%rax,8),%xmm3
subsd  %xmm4,%xmm3
movsd  %xmm3,-0x8(%rdi,%rax,8)
mov    (%rbx,%rdx,8),%rdi
movsd  (%rdi,%r14,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r12,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  -0x8(%rdi,%rax,8),%xmm3
subsd  %xmm4,%xmm3
movsd  %xmm3,-0x8(%rdi,%rax,8)
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
jne    1430 <mytred2+0x310>
test   $0x1,%al
je     13e0 <mytred2+0x2c0>
mov    -0x8(%rbx,%rdx,8),%rsi
mulsd  (%rsi,%r14,8),%xmm2
mulsd  -0x8(%r12,%rdx,8),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x8(%rsi,%rax,8),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,-0x8(%rsi,%rax,8)
jmp    13e0 <mytred2+0x2c0>
mov    (%rbx),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%r12)
mov    0x10(%rsp),%rax
movq   $0x0,(%rax,%r14,8)
mov    0x10(%rsp),%rax
movq   $0x0,(%rax)
movq   $0x0,(%r12)
cmpl   $0x0,0x8(%rsp)
jle    1894 <mytred2+0x774>
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%eax
movq   $0xfffffffffffffffc,0x30(%rsp)
ff ff
xor    %r13d,%r13d
xorpd  %xmm8,%xmm8
movapd 0xacb(%rip),%xmm1
jmp    1559 <mytred2+0x439>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%r13
addq   $0x1,0x30(%rsp)
cmp    0x8(%rsp),%rax
je     1894 <mytred2+0x774>
mov    %r13,%r12
and    $0xfffffffffffffffe,%r12
neg    %r12
mov    0x10(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm2
ucomisd %xmm8,%xmm2
jne    157b <mytred2+0x45b>
jnp    17f0 <mytred2+0x6d0>
cmp    $0x2,%rax
jb     17f0 <mytred2+0x6d0>
mov    0x30(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
lea    -0x4(%r13),%r10
mov    %r10,0x18(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
mov    -0x8(%rbx,%rax,8),%rbp
lea    0x0(,%r13,8),%r9
add    %rbp,%r9
mov    %r13,%r11
and    $0xfffffffffffffffc,%r11
lea    0x1(%r11),%rcx
mov    %rcx,0x28(%rsp)
mov    $0x1,%r8d
jmp    15ed <mytred2+0x4cd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
cmp    %rax,%r8
je     17f0 <mytred2+0x6d0>
mov    -0x8(%rbx,%r8,8),%rsi
xorpd  %xmm2,%xmm2
mov    $0x1,%ecx
cmp    $0x1,%r13
je     164a <mytred2+0x52a>
xorpd  %xmm2,%xmm2
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
mov    -0x8(%rbx,%rcx,8),%rdx
mov    (%rbx,%rcx,8),%rdi
movsd  -0x8(%rdx,%rax,8),%xmm0
mulsd  -0x8(%rsi,%rcx,8),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x8(%rdi,%rax,8),%xmm2
mulsd  (%rsi,%rcx,8),%xmm2
addsd  %xmm0,%xmm2
lea    (%r12,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    1610 <mytred2+0x4f0>
test   $0x1,%r13b
je     1665 <mytred2+0x545>
mov    -0x8(%rbx,%rcx,8),%rdx
movsd  -0x8(%rdx,%rax,8),%xmm3
mulsd  -0x8(%rsi,%rcx,8),%xmm3
addsd  %xmm3,%xmm2
xorpd  %xmm1,%xmm2
mov    -0x8(%rbx,%r8,8),%r14
mov    $0x1,%ecx
cmp    $0x4,%r13
jb     1780 <mytred2+0x660>
cmp    %r9,%r14
jae    168f <mytred2+0x56f>
lea    (%r14,%r13,8),%rdx
cmp    %rdx,%rbp
jb     1780 <mytred2+0x660>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x4,0x18(%rsp)
jae    16a7 <mytred2+0x587>
xor    %r15d,%r15d
jmp    172c <mytred2+0x60c>
mov    0x20(%rsp),%rcx
xor    %r15d,%r15d
nop
movupd 0x0(%rbp,%r15,8),%xmm4
movupd 0x10(%rbp,%r15,8),%xmm5
mulpd  %xmm3,%xmm4
movupd (%r14,%r15,8),%xmm6
addpd  %xmm4,%xmm6
movupd 0x10(%r14,%r15,8),%xmm4
movupd 0x20(%r14,%r15,8),%xmm7
movupd 0x30(%r14,%r15,8),%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,(%r14,%r15,8)
movupd %xmm5,0x10(%r14,%r15,8)
movupd 0x20(%rbp,%r15,8),%xmm4
movupd 0x30(%rbp,%r15,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movupd %xmm4,0x20(%r14,%r15,8)
movupd %xmm5,0x30(%r14,%r15,8)
add    $0x8,%r15
add    $0xfffffffffffffffe,%rcx
jne    16b0 <mytred2+0x590>
test   $0x1,%r10b
je     176a <mytred2+0x64a>
movupd 0x0(%rbp,%r15,8),%xmm0
movupd 0x10(%rbp,%r15,8),%xmm4
movupd (%r14,%r15,8),%xmm5
movupd 0x10(%r14,%r15,8),%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm0,(%r14,%r15,8)
movupd %xmm4,0x10(%r14,%r15,8)
mov    0x28(%rsp),%rcx
cmp    %r11,%r13
je     15e0 <mytred2+0x4c0>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
test   $0x1,%al
jne    17a3 <mytred2+0x683>
movsd  -0x8(%rbp,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rcx,8)
lea    0x1(%rcx),%rsi
cmp    %rcx,%r13
je     15e0 <mytred2+0x4c0>
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%r14,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rsi,8)
movsd  0x0(%rbp,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r14,%rsi,8),%xmm0
movsd  %xmm0,(%r14,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    17b0 <mytred2+0x690>
jmp    15e0 <mytred2+0x4c0>
nopl   0x0(%rax)
mov    -0x8(%rbx,%rax,8),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm0
mov    0x10(%rsp),%rdx
movsd  %xmm0,-0x8(%rdx,%rax,8)
movabs $0x3ff0000000000000,%rdx
mov    %rdx,-0x8(%rcx,%rax,8)
cmp    $0x2,%rax
jb     1540 <mytred2+0x420>
mov    $0x1,%esi
cmp    $0x1,%r13
je     186e <mytred2+0x74e>
mov    $0x1,%esi
nop
mov    -0x8(%rbx,%rsi,8),%rdx
movq   $0x0,-0x8(%rdx,%rax,8)
movq   $0x0,-0x8(%rcx,%rsi,8)
mov    (%rbx,%rsi,8),%rdx
movq   $0x0,-0x8(%rdx,%rax,8)
movq   $0x0,(%rcx,%rsi,8)
lea    (%r12,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
cmp    $0x1,%rdx
jne    1830 <mytred2+0x710>
test   $0x1,%r13b
je     1540 <mytred2+0x420>
mov    -0x8(%rbx,%rsi,8),%rdx
movq   $0x0,-0x8(%rdx,%rax,8)
movq   $0x0,-0x8(%rcx,%rsi,8)
jmp    1540 <mytred2+0x420>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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