#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*/ exit(int);
int /*<<< orphan*/ eye(double *, int);
int /*<<< orphan*/ free(double *);
double house(double *, int, double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(double *, double *, double *, int, int, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scale(double *, int, int, double);
void bidiag_orth(double *A, int M, int N, double *U, double *V) {
  int j, i, k, u, t;
  double *x, *v, *AT, *w;
  double beta;
  if (M < N) {
    printf("M should be greater than or equal to N");
    exit(1);
  }
  x = (double *)malloc(sizeof(double) * M);
  v = (double *)malloc(sizeof(double) * M);
  AT = (double *)malloc(sizeof(double) * M * M);
  w = (double *)malloc(sizeof(double) * M * M);
  eye(U, M);
  eye(V, N);
  for (j = 0; j < N; ++j) {
    for (i = j; i < M; ++i) {
      x[i - j] = A[i * N + j];
    }
    beta = house(x, M - j, v);
    for (i = j; i < M; i++) {
      t = i * N;
      u = 0;
      for (k = j; k < N; k++) {
        AT[u + i - j] = A[k + t];
        u += (M - j);
      }
    }
    mmult(AT, v, w, N - j, M - j, 1);
    scale(w, N - j, 1, beta);
    mmult(v, w, AT, M - j, 1, N - j);
    for (i = j; i < M; i++) {
      t = i * N;
      for (k = j; k < N; k++) {
        A[t + k] -= AT[(i - j) * (N - j) + k - j];
      }
    }
    for (i = j + 1; i < M; ++i) {
      A[i * N + j] = v[i - j];
    }
    for (i = j; i < M; i++) {
      t = i * M;
      u = (i - j) * (M - j);
      for (k = j; k < M; k++) {
        AT[u + k - j] = U[k + t];
      }
    }
    mmult(AT, v, w, M - j, M - j, 1);
    scale(w, M - j, 1, beta);
    mmult(w, v, AT, M - j, 1, M - j);
    for (i = j; i < M; i++) {
      t = i * M;
      u = (i - j) * (M - j);
      for (k = j; k < M; k++) {
        U[k + t] -= AT[u + k - j];
      }
    }
    if (j < N - 2) {
      for (i = j + 1; i < N; ++i) {
        x[i - j - 1] = A[j * N + i];
      }
      beta = house(x, N - j - 1, v);
      for (i = j; i < M; i++) {
        t = i * N;
        u = (i - j) * (N - j - 1);
        for (k = j + 1; k < N; k++) {
          AT[u + k - j - 1] = A[k + t];
        }
      }
      mmult(AT, v, w, M - j, N - j - 1, 1);
      scale(w, M - j, 1, beta);
      mmult(w, v, AT, M - j, 1, N - j - 1);
      for (i = j; i < M; i++) {
        t = i * N;
        u = (i - j) * (N - j - 1);
        for (k = j + 1; k < N; k++) {
          A[k + t] -= AT[u + k - j - 1];
        }
      }
      u = 1;
      t = j * N;
      for (i = j + 2; i < N; ++i) {
        A[t + i] = v[u];
        u++;
      }
    }
  }
  free(x);
  free(v);
  free(AT);
}


x86 assembly (clang, -O0):
<bidiag_orth>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11bc <bidiag_orth+0x3c>
lea    0xe53(%rip),%rdi
call   1050 <printf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <eye@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1060 <eye@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1865 <bidiag_orth+0x6e5>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128b <bidiag_orth+0x10b>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1249 <bidiag_orth+0xc9>
mov    -0x40(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x24(%rbp),%esi
mov    -0x48(%rbp),%rdx
call   1090 <house@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    132c <bidiag_orth+0x1ac>
mov    -0x28(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1319 <bidiag_orth+0x199>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
sub    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12cc <bidiag_orth+0x14c>
jmp    131e <bidiag_orth+0x19e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12a9 <bidiag_orth+0x129>
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x10(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%r8d
sub    -0x24(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x58(%rbp),%rdi
mov    -0x10(%rbp),%esi
sub    -0x24(%rbp),%esi
movsd  -0x60(%rbp),%xmm0
mov    $0x1,%edx
call   1080 <scale@plt>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%r9d
sub    -0x24(%rbp),%r9d
mov    $0x1,%r8d
call   1040 <mmult@plt>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    141a <bidiag_orth+0x29a>
mov    -0x28(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1407 <bidiag_orth+0x287>
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    -0x24(%rbp),%edx
imul   %edx,%ecx
add    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13b1 <bidiag_orth+0x231>
jmp    140c <bidiag_orth+0x28c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1395 <bidiag_orth+0x215>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1465 <bidiag_orth+0x2e5>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1423 <bidiag_orth+0x2a3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ed <bidiag_orth+0x36d>
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14da <bidiag_orth+0x35a>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1499 <bidiag_orth+0x319>
jmp    14df <bidiag_orth+0x35f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    146b <bidiag_orth+0x2eb>
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%r8d
sub    -0x24(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x24(%rbp),%esi
movsd  -0x60(%rbp),%xmm0
mov    $0x1,%edx
call   1080 <scale@plt>
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%r9d
sub    -0x24(%rbp),%r9d
mov    $0x1,%r8d
call   1040 <mmult@plt>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15e1 <bidiag_orth+0x461>
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15ce <bidiag_orth+0x44e>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1584 <bidiag_orth+0x404>
jmp    15d3 <bidiag_orth+0x453>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1556 <bidiag_orth+0x3d6>
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1852 <bidiag_orth+0x6d2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1640 <bidiag_orth+0x4c0>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15fb <bidiag_orth+0x47b>
mov    -0x40(%rbp),%rdi
mov    -0x10(%rbp),%esi
sub    -0x24(%rbp),%esi
sub    $0x1,%esi
mov    -0x48(%rbp),%rdx
call   1090 <house@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16ec <bidiag_orth+0x56c>
mov    -0x28(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16d9 <bidiag_orth+0x559>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1695 <bidiag_orth+0x515>
jmp    16de <bidiag_orth+0x55e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1661 <bidiag_orth+0x4e1>
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%r8d
sub    -0x24(%rbp),%r8d
sub    $0x1,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x24(%rbp),%esi
movsd  -0x60(%rbp),%xmm0
mov    $0x1,%edx
call   1080 <scale@plt>
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%r9d
sub    -0x24(%rbp),%r9d
sub    $0x1,%r9d
mov    $0x1,%r8d
call   1040 <mmult@plt>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17f1 <bidiag_orth+0x671>
mov    -0x28(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    17de <bidiag_orth+0x65e>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1791 <bidiag_orth+0x611>
jmp    17e3 <bidiag_orth+0x663>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    175d <bidiag_orth+0x5dd>
movl   $0x1,-0x30(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    184d <bidiag_orth+0x6cd>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180b <bidiag_orth+0x68b>
jmp    1852 <bidiag_orth+0x6d2>
jmp    1857 <bidiag_orth+0x6d7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1237 <bidiag_orth+0xb7>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bidiag_orth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
mov    %r8,(%rsp)
mov    %rdi,0x18(%rsp)
cmp    %edx,%esi
jl     2cb5 <bidiag_orth+0x1b35>
mov    %rcx,%rbx
mov    %edx,%ebp
lea    0x0(,%rsi,8),%r13d
mov    %r13d,%edi
mov    %rsi,0xe0(%rsp)
call   1070 <malloc@plt>
mov    %rax,%r12
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
imul   0xe0(%rsp),%r13d
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %rbx,%rdi
mov    0xe0(%rsp),%rsi
call   1060 <eye@plt>
mov    (%rsp),%rdi
mov    %ebp,%esi
call   1060 <eye@plt>
mov    0xe0(%rsp),%rdx
test   %ebp,%ebp
mov    %rbp,0x1a0(%rsp)
jle    2c8c <bidiag_orth+0x1b0c>
mov    0x1a0(%rsp),%r13
lea    -0x2(%r13),%eax
mov    %r13d,%r8d
movslq %edx,%r11
cltq
mov    %rax,0x268(%rsp)
mov    %edx,%esi
mov    0x18(%rsp),%rax
lea    -0x8(%rax),%rdi
mov    %rdi,0x248(%rsp)
lea    -0x1(%r13),%ecx
mov    %rcx,0x128(%rsp)
lea    0x8(%r15),%rbp
mov    %rbp,0x240(%rsp)
lea    -0x2(%r8),%rbp
mov    %rbp,0x258(%rsp)
lea    0x0(,%r8,8),%r9
mov    %rsi,%rbp
neg    %rbp
mov    %rbp,0x190(%rsp)
mov    %r8,%rbp
neg    %rbp
mov    %rbp,0x230(%rsp)
mov    %r8,%rbp
shl    $0x20,%rbp
lea    0x8(,%r8,8),%rcx
mov    %rcx,0x210(%rsp)
lea    0x8(%rax),%rcx
mov    %rcx,0x198(%rsp)
lea    -0x1(%rsi),%rcx
mov    %rcx,0x260(%rsp)
lea    0x0(,%r11,8),%rcx
mov    %rcx,0x188(%rsp)
mov    %r11,0x38(%rsp)
lea    0x8(,%r11,8),%rcx
mov    %rcx,0x200(%rsp)
lea    -0x1(%r8),%rcx
lea    0x10(%rax),%rdi
mov    %rdi,0x130(%rsp)
lea    (%rax,%r8,8),%r11
mov    %r11,0x1f8(%rsp)
lea    0x30(%rbx),%rdi
mov    %rdi,0x1f0(%rsp)
lea    -0x4(%rsi),%rdi
mov    %rdi,0x1e8(%rsp)
lea    0x10(%rbx),%rdi
mov    %rdi,0x1c8(%rsp)
lea    0x8(%rbx),%rdi
mov    %rdi,0x1c0(%rsp)
lea    -0x5(%r8),%rdi
mov    %rdi,0x1e0(%rsp)
lea    -0x8(%r12),%rdi
lea    0x8(%r12),%r11
mov    %rbp,0x238(%rsp)
movabs $0xffffffff00000000,%r10
ff ff ff
lea    0x0(%rbp,%r10,1),%rbp
mov    %rbp,0x180(%rsp)
lea    0x38(%rax),%rbp
mov    %rbp,0x1b8(%rsp)
lea    0x18(%rax),%rbp
mov    %rbp,0x1b0(%rsp)
lea    0x18(%r15),%rbp
mov    %rbp,0x250(%rsp)
movl   $0x2,0xd4(%rsp)
mov    $0x1,%ebp
mov    %rbp,0x148(%rsp)
xor    %ebp,%ebp
mov    %rbp,0x178(%rsp)
movl   $0x1,0xd8(%rsp)
movq   $0xffffffffffffffff,0x138(%rsp)
mov    $0x2,%ebp
mov    %rbp,0x1a8(%rsp)
mov    0x128(%rsp),%rbp
mov    %ebp,0x8c(%rsp)
mov    %rcx,0x118(%rsp)
mov    %rcx,0x110(%rsp)
mov    %rax,%r10
mov    %rbx,0x1d8(%rsp)
mov    0x198(%rsp),%rcx
mov    %rcx,0xe8(%rsp)
mov    0x130(%rsp),%rcx
mov    %rcx,0x1d0(%rsp)
mov    %r8,0x120(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rsi,0x170(%rsp)
mov    %rax,%rbp
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r13d,%eax
mov    %r13d,0xdc(%rsp)
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    %edx,%eax
mov    %rax,0x168(%rsp)
xor    %r13d,%r13d
mov    %rbx,0x58(%rsp)
mov    %r12,0x208(%rsp)
mov    %r8,0x20(%rsp)
mov    %r9,0x80(%rsp)
mov    %r15,0xb0(%rsp)
jmp    15d9 <bidiag_orth+0x459>
nopl   0x0(%rax)
addl   $0xffffffff,0xdc(%rsp)
ff
addq   $0xffffffffffffffff,0x48(%rsp)
mov    0x168(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x168(%rsp)
addq   $0x1,0x10(%rsp)
addl   $0x1,0xd4(%rsp)
01
mov    0x210(%rsp),%rcx
add    %rcx,%rbp
addq   $0xffffffffffffffff,0x170(%rsp)
addq   $0xffffffffffffffff,0x120(%rsp)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x238(%rsp)
add    %rcx,0x1d0(%rsp)
addq   $0xffffffffffffffff,0x148(%rsp)
add    %r9,0xe8(%rsp)
add    %rcx,0x1f8(%rsp)
mov    0x200(%rsp),%rsi
add    %rsi,0x1f0(%rsp)
addq   $0xffffffffffffffff,0x1e8(%rsp)
mov    0x188(%rsp),%rdx
add    %rdx,0x1d8(%rsp)
mov    0x178(%rsp),%rdi
add    $0xffffffff,%edi
mov    %rdi,0x178(%rsp)
addl   $0xffffffff,0xd8(%rsp)
ff
add    %rsi,0x1c8(%rsp)
add    %rdx,0x1c0(%rsp)
addq   $0xffffffffffffffff,0x1e0(%rsp)
mov    0x218(%rsp),%rdi
add    $0xfffffffffffffff8,%rdi
add    %r9,%r10
add    $0xfffffffffffffff8,%r11
add    %rax,0x180(%rsp)
add    %rcx,0x1b8(%rsp)
addq   $0xffffffffffffffff,0x138(%rsp)
addq   $0xffffffffffffffff,0x110(%rsp)
add    %rcx,0x1b0(%rsp)
mov    0x40(%rsp),%rax
add    $0xffffffff,%eax
add    %r9,0x130(%rsp)
add    %r8,0x1a8(%rsp)
mov    %eax,0x8c(%rsp)
cmp    %r8,%r13
mov    0xe0(%rsp),%rdx
je     2c8c <bidiag_orth+0x1b0c>
mov    %r13,%rax
imul   %r8,%rax
mov    %rax,0xf0(%rsp)
cmp    0x38(%rsp),%r13
mov    %rbp,0xf8(%rsp)
mov    %r13,(%rsp)
mov    %rdi,0x218(%rsp)
mov    %r11,0x228(%rsp)
mov    %r10,0x220(%rsp)
jge    16f0 <bidiag_orth+0x570>
mov    0x168(%rsp),%rbx
shl    $0x20,%rbx
mov    %rbp,%rax
xor    %ecx,%ecx
mov    0x170(%rsp),%rsi
movsd  (%rax),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
add    %r9,%rax
cmp    %rcx,%rsi
jne    1630 <bidiag_orth+0x4b0>
mov    %edx,%esi
mov    (%rsp),%r13
sub    %r13d,%esi
mov    %r12,%rdi
mov    %esi,0x28(%rsp)
mov    %r15,%rdx
call   1090 <house@plt>
cmp    0x38(%rsp),%r13
movsd  %xmm0,0x78(%rsp)
jge    1720 <bidiag_orth+0x5a0>
mov    %rbp,%rax
xor    %r12d,%r12d
mov    0x20(%rsp),%r8
mov    0x50(%rsp),%r9
mov    0x80(%rsp),%r10
movabs $0x100000000,%r11
mov    0x120(%rsp),%rbp
nopl   0x0(%rax)
xor    %esi,%esi
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rsi,8),%xmm1
mov    %rcx,%rdi
sar    $0x1d,%rdi
movsd  %xmm1,(%r14,%rdi,1)
add    %rbx,%rcx
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    16b0 <bidiag_orth+0x530>
add    $0x1,%r13
add    %r11,%r12
add    %r10,%rax
cmp    %r9,%r13
jne    16a0 <bidiag_orth+0x520>
mov    (%rsp),%rbx
jmp    1728 <bidiag_orth+0x5a8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rbx
mov    %edx,%r13d
sub    %ebx,%r13d
mov    %r12,%rdi
mov    %r13d,%esi
mov    %r15,%rdx
call   1090 <house@plt>
mov    0x20(%rsp),%r8
movsd  %xmm0,0x78(%rsp)
jmp    172d <bidiag_orth+0x5ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%r8
mov    %r13,%rbx
mov    0x28(%rsp),%r13d
mov    0x210(%rsp),%rax
imul   %rbx,%rax
mov    %rax,0x108(%rsp)
mov    0xf0(%rsp),%rax
add    %r8,%rax
mov    %rax,0x100(%rsp)
mov    %r8,%rbp
sub    %rbx,%rbp
mov    0x1a0(%rsp),%rax
mov    %eax,%r12d
sub    %ebx,%r12d
mov    %r14,%rdi
mov    %r15,%rsi
mov    0xa8(%rsp),%rbx
mov    %rbx,%rdx
mov    %r12d,%ecx
mov    %r13d,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbx,%rdi
mov    %rbp,0xc8(%rsp)
mov    %ebp,%esi
mov    $0x1,%edx
movsd  0x78(%rsp),%xmm0
call   1080 <scale@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    (%rsp),%rbx
mov    %r14,%rdx
mov    %r13d,0x28(%rsp)
mov    %r13d,%ecx
mov    $0x1,%r8d
mov    %r12d,0x6c(%rsp)
mov    %r12d,%r9d
call   1040 <mmult@plt>
cmp    0x38(%rsp),%rbx
movabs $0x200000000,%rdi
jge    1a80 <bidiag_orth+0x900>
mov    0x20(%rsp),%rax
mov    0x48(%rsp),%r12
lea    (%r12,%rax,1),%rcx
mov    0x120(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
lea    (%r14,%rcx,8),%rax
mov    %rax,0x70(%rsp)
mov    0x118(%rsp),%rax
add    %r12,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,0x8(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x40(%rsp)
lea    (%rbx,%rcx,1),%rax
mov    %rax,0xa0(%rsp)
mov    0xe8(%rsp),%rbp
mov    0x148(%rsp),%r13
mov    0x1d0(%rsp),%rsi
xor    %r15d,%r15d
xor    %r8d,%r8d
mov    %rbx,%r9
jmp    189b <bidiag_orth+0x71b>
nopl   0x0(%rax)
add    $0x1,%r9
add    $0x1,%r8
add    0x238(%rsp),%r15
mov    0x80(%rsp),%rax
add    %rax,%rsi
mov    0x120(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%r13
add    %rax,%rbp
cmp    0x50(%rsp),%r9
mov    (%rsp),%rbx
je     1a80 <bidiag_orth+0x900>
mov    %rbx,%r11
cmpq   $0x4,0x8(%rsp)
mov    0x20(%rsp),%rdx
jae    1970 <bidiag_orth+0x7f0>
mov    %edx,%eax
sub    %r11d,%eax
mov    %r11,%r10
test   $0x1,%al
je     18fb <bidiag_orth+0x77b>
mov    %r9,%rax
imul   0x20(%rsp),%rax
mov    %r9,%rcx
sub    (%rsp),%rcx
imul   0xc8(%rsp),%rcx
add    0x48(%rsp),%rcx
add    %r11d,%ecx
movslq %ecx,%rcx
add    %r11,%rax
mov    0x18(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
subsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
lea    0x1(%r11),%r10
cmp    %r11,0x118(%rsp)
mov    0x20(%rsp),%rdx
je     1860 <bidiag_orth+0x6e0>
lea    (%r10,%r12,1),%ebx
shl    $0x20,%rbx
lea    (%r10,%r13,1),%ecx
shl    $0x20,%rcx
xchg   %ax,%ax
mov    %rbx,%rax
sar    $0x1d,%rax
movsd  -0x8(%rbp,%r10,8),%xmm0
movsd  0x0(%rbp,%r10,8),%xmm1
subsd  (%r14,%rax,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%r10,8)
mov    %rcx,%rax
sar    $0x1d,%rax
subsd  (%r14,%rax,1),%xmm1
movsd  %xmm1,0x0(%rbp,%r10,8)
add    $0x2,%r10
add    %rdi,%rbx
add    %rdi,%rcx
cmp    %r10,%rdx
jne    1920 <bidiag_orth+0x7a0>
jmp    1860 <bidiag_orth+0x6e0>
nopw   0x0(%rax,%rax,1)
mov    0xdc(%rsp),%eax
mov    %eax,%ecx
imul   %r8d,%ecx
mov    0x30(%rsp),%rax
lea    (%rcx,%rax,1),%ebx
mov    (%rsp),%r11
cmp    %ecx,%ebx
jl     18af <bidiag_orth+0x72f>
mov    0x30(%rsp),%rcx
shr    $0x20,%rcx
mov    (%rsp),%r11
jne    18af <bidiag_orth+0x72f>
mov    %r8,%rcx
imul   %rdx,%rcx
mov    0x18(%rsp),%rax
lea    (%rax,%rcx,8),%rbx
add    0x108(%rsp),%rbx
mov    0x8(%rsp),%rax
imul   %r8d,%eax
movslq %eax,%r10
mov    0x70(%rsp),%rax
lea    (%rax,%r10,8),%rax
cmp    %rax,%rbx
jae    19f8 <bidiag_orth+0x878>
add    0x100(%rsp),%rcx
mov    0x18(%rsp),%rax
lea    (%rax,%rcx,8),%rax
lea    (%r14,%r10,8),%rcx
mov    (%rsp),%r11
cmp    %rax,%rcx
jb     18af <bidiag_orth+0x72f>
mov    %r15,%rcx
xor    %ebx,%ebx
movabs $0x400000000,%rdi
mov    0x60(%rsp),%rdx
nopl   0x0(%rax)
mov    %rcx,%rax
sar    $0x1d,%rax
movupd (%r14,%rax,1),%xmm0
movupd 0x10(%r14,%rax,1),%xmm1
movupd -0x10(%rsi,%rbx,8),%xmm2
subpd  %xmm0,%xmm2
movupd (%rsi,%rbx,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rsi,%rbx,8)
movupd %xmm0,(%rsi,%rbx,8)
add    $0x4,%rbx
add    %rdi,%rcx
cmp    %rbx,%rdx
jne    1a10 <bidiag_orth+0x890>
mov    0xa0(%rsp),%r11
mov    0x40(%rsp),%rax
cmp    %rax,0x8(%rsp)
movabs $0x200000000,%rdi
mov    0x20(%rsp),%rdx
je     1860 <bidiag_orth+0x6e0>
jmp    18af <bidiag_orth+0x72f>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbx),%r13
mov    0x38(%rsp),%rdi
cmp    %rdi,%r13
mov    0xb0(%rsp),%rbx
mov    0x80(%rsp),%rdx
mov    0x170(%rsp),%rsi
jge    1ad5 <bidiag_orth+0x955>
mov    $0x1,%eax
mov    0x1f8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
add    %rdx,%rcx
add    $0x1,%rax
cmp    %rax,%rsi
jne    1ac0 <bidiag_orth+0x940>
mov    (%rsp),%r12
cmp    %rdi,%r12
mov    %r13,0xa0(%rsp)
jge    1e30 <bidiag_orth+0xcb0>
mov    0x1e8(%rsp),%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    0x50(%rsp),%rax
mov    0x48(%rsp),%r8
lea    (%r8,%rax,1),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x160(%rsp)
shr    $0x2,%rdx
lea    (%r8,%rax,1),%rcx
mov    %r12,%rbp
imul   %rdi,%rbp
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x140(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x270(%rsp)
add    $0x1,%rdx
mov    %rdx,0x158(%rsp)
mov    0x200(%rsp),%rsi
imul   %r12,%rsi
mov    %rsi,0xc0(%rsp)
add    %rax,%rbp
mov    %rbp,0x98(%rsp)
lea    (%r14,%rcx,8),%rax
mov    %rax,0xb8(%rsp)
mov    0x260(%rsp),%rax
add    %r8,%rax
mov    %rax,0x40(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x90(%rsp)
lea    (%r12,%rdx,1),%rax
mov    %rax,0x150(%rsp)
mov    0x28(%rsp),%esi
mov    %esi,%eax
mov    %rax,0x70(%rsp)
mov    $0x4,%r13d
mov    0xd8(%rsp),%eax
mov    %eax,0x60(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x1d8(%rsp),%r15
mov    %r12,%r9
xor    %r12d,%r12d
mov    0x1f0(%rsp),%rdx
xor    %r8d,%r8d
mov    0x58(%rsp),%r11
jmp    1c30 <bidiag_orth+0xab0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x1,%r8
mov    0x188(%rsp),%rax
add    %rax,%rdx
mov    0x70(%rsp),%rcx
add    %rcx,%r13
add    %rcx,%r12
add    %rax,%r15
mov    0x28(%rsp),%esi
mov    0x8(%rsp),%rax
add    %esi,%eax
mov    %rax,0x8(%rsp)
add    %esi,0x60(%rsp)
cmp    0x50(%rsp),%r9
je     1e90 <bidiag_orth+0xd10>
mov    %r9,%r10
imul   0x38(%rsp),%r10
mov    %r9d,%ebx
mov    (%rsp),%rcx
sub    %ecx,%ebx
imul   %esi,%ebx
add    0x48(%rsp),%ebx
cmpq   $0x4,0x30(%rsp)
jae    1cf0 <bidiag_orth+0xb70>
mov    0x50(%rsp),%rax
sub    %ecx,%eax
mov    %rcx,%rsi
test   $0x1,%al
je     1c7b <bidiag_orth+0xafb>
add    %rcx,%r10
movsd  (%r11,%r10,8),%xmm0
add    %ecx,%ebx
movslq %ebx,%rax
movsd  %xmm0,(%r14,%rax,8)
lea    0x1(%rcx),%rsi
not    %rcx
cmp    0x190(%rsp),%rcx
je     1bf0 <bidiag_orth+0xa70>
mov    0x190(%rsp),%rax
lea    (%rax,%rsi,1),%rcx
lea    (%r15,%rsi,8),%rbx
mov    0x8(%rsp),%rax
add    %esi,%eax
add    0x60(%rsp),%esi
mov    $0x1,%edi
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdi,8),%xmm0
cltq
movsd  %xmm0,(%r14,%rax,8)
movsd  (%rbx,%rdi,8),%xmm0
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
lea    (%rcx,%rdi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdi
add    $0x2,%eax
add    $0x2,%esi
cmp    $0x1,%rbp
jne    1cb0 <bidiag_orth+0xb30>
jmp    1bf0 <bidiag_orth+0xa70>
nopl   0x0(%rax)
mov    0x28(%rsp),%eax
imul   %r8d,%eax
mov    0x40(%rsp),%rcx
lea    (%rax,%rcx,1),%esi
mov    (%rsp),%rcx
cmp    %eax,%esi
jl     1c55 <bidiag_orth+0xad5>
mov    0x40(%rsp),%rcx
shr    $0x20,%rcx
mov    (%rsp),%rcx
jne    1c55 <bidiag_orth+0xad5>
mov    %r8,%rcx
imul   0x38(%rsp),%rcx
lea    (%r11,%rcx,8),%rsi
add    0xc0(%rsp),%rsi
cltq
mov    0xb8(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,%rsi
jae    1d64 <bidiag_orth+0xbe4>
add    0x98(%rsp),%rcx
lea    (%r11,%rcx,8),%rsi
lea    (%r14,%rax,8),%rax
mov    (%rsp),%rcx
cmp    %rsi,%rax
jb     1c55 <bidiag_orth+0xad5>
cmpq   $0x4,0x160(%rsp)
jae    1d74 <bidiag_orth+0xbf4>
xor    %r11d,%r11d
jmp    1dc8 <bidiag_orth+0xc48>
mov    0x270(%rsp),%rcx
xor    %r11d,%r11d
nop
movups -0x30(%rdx,%r11,8),%xmm0
movups -0x20(%rdx,%r11,8),%xmm1
lea    (%r12,%r11,1),%eax
cltq
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movupd -0x10(%rdx,%r11,8),%xmm0
movupd (%rdx,%r11,8),%xmm1
lea    0x0(%r13,%r11,1),%eax
cltq
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rcx
jne    1d80 <bidiag_orth+0xc00>
testb  $0x1,0x158(%rsp)
01
je     1dff <bidiag_orth+0xc7f>
add    (%rsp),%r11
mov    %r11,%rax
add    %r10,%rax
mov    0x58(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
lea    (%rbx,%r11,1),%eax
cltq
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
mov    0x150(%rsp),%rcx
mov    0x90(%rsp),%rax
cmp    %rax,0x30(%rsp)
mov    0x58(%rsp),%r11
je     1bf0 <bidiag_orth+0xa70>
jmp    1c55 <bidiag_orth+0xad5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
mov    %rbx,%rsi
mov    0xa8(%rsp),%r15
mov    %r15,%rdx
mov    0x28(%rsp),%ebp
mov    %ebp,%ecx
mov    %ebp,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %r15,%rdi
mov    %ebp,%esi
mov    $0x1,%edx
movsd  0x78(%rsp),%xmm0
call   1080 <scale@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %ebp,%ecx
mov    $0x1,%r8d
mov    %ebp,%r9d
call   1040 <mmult@plt>
mov    %r12,%rbx
jmp    2120 <bidiag_orth+0xfa0>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    0xb0(%rsp),%r15
mov    %esi,%ebx
mov    %r15,%rsi
mov    0xa8(%rsp),%rbp
mov    %rbp,%rdx
mov    %ebx,%ecx
mov    %ebx,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x1,%edx
movsd  0x78(%rsp),%xmm0
call   1080 <scale@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    $0x1,%r8d
mov    %ebx,%r9d
call   1040 <mmult@plt>
mov    0x58(%rsp),%r11
mov    (%rsp),%rbx
cmp    0x38(%rsp),%rbx
mov    0xa0(%rsp),%r13
jge    2120 <bidiag_orth+0xfa0>
mov    0x90(%rsp),%rax
add    %rbx,%rax
mov    %rax,0x8(%rsp)
mov    0x1c0(%rsp),%rcx
mov    0x48(%rsp),%rdx
mov    0x148(%rsp),%rsi
mov    0x1c8(%rsp),%rdi
xor    %r12d,%r12d
xor    %r9d,%r9d
mov    %rbx,%r10
jmp    1f71 <bidiag_orth+0xdf1>
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%r9
mov    0x70(%rsp),%rbx
add    %rbx,%r12
mov    0x188(%rsp),%rax
add    %rax,%rdi
add    %rbx,%rsi
add    %rbx,%rdx
add    %rax,%rcx
cmp    %r8,%r10
mov    (%rsp),%rbx
je     2120 <bidiag_orth+0xfa0>
cmpq   $0x4,0x30(%rsp)
mov    0x50(%rsp),%r8
jb     2080 <bidiag_orth+0xf00>
mov    0x28(%rsp),%eax
imul   %r9d,%eax
mov    0x40(%rsp),%rbp
lea    (%rax,%rbp,1),%r11d
mov    (%rsp),%rbx
cmp    %eax,%r11d
mov    0x58(%rsp),%r11
jl     2080 <bidiag_orth+0xf00>
mov    0x40(%rsp),%rbx
shr    $0x20,%rbx
mov    (%rsp),%rbx
jne    2080 <bidiag_orth+0xf00>
mov    %r9,%rbx
imul   0x38(%rsp),%rbx
mov    0x58(%rsp),%rbp
lea    0x0(,%rbx,8),%r11
add    %rbp,%r11
add    0xc0(%rsp),%r11
movslq %eax,%r15
mov    0xb8(%rsp),%rax
lea    (%rax,%r15,8),%rax
cmp    %rax,%r11
mov    0x58(%rsp),%r11
jae    2015 <bidiag_orth+0xe95>
add    0x98(%rsp),%rbx
mov    0x58(%rsp),%rax
lea    (%rax,%rbx,8),%r11
lea    (%r14,%r15,8),%rax
mov    (%rsp),%rbx
cmp    %r11,%rax
mov    0x58(%rsp),%r11
jb     2080 <bidiag_orth+0xf00>
xor    %eax,%eax
mov    0x140(%rsp),%rbp
nop
lea    (%r12,%rax,1),%ebx
movslq %ebx,%rbx
movupd (%r14,%rbx,8),%xmm0
movupd 0x10(%r14,%rbx,8),%xmm1
movupd -0x10(%rdi,%rax,8),%xmm2
subpd  %xmm0,%xmm2
movupd (%rdi,%rax,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rdi,%rax,8)
movupd %xmm0,(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2020 <bidiag_orth+0xea0>
mov    0x8(%rsp),%rbx
mov    0x90(%rsp),%rax
cmp    %rax,0x30(%rsp)
mov    0x50(%rsp),%r8
je     1f40 <bidiag_orth+0xdc0>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%ebp
sub    %ebx,%ebp
mov    %rbx,%rax
test   $0x1,%bpl
je     20c4 <bidiag_orth+0xf44>
mov    %r10,%rax
imul   0x38(%rsp),%rax
mov    %r10d,%ebp
sub    (%rsp),%ebp
imul   0x28(%rsp),%ebp
add    0x48(%rsp),%ebp
add    %ebx,%ebp
movslq %ebp,%rbp
add    %rbx,%rax
movsd  (%r11,%rax,8),%xmm0
subsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
lea    0x1(%rbx),%rax
not    %rbx
cmp    0x190(%rsp),%rbx
mov    0x50(%rsp),%r8
je     1f40 <bidiag_orth+0xdc0>
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%rax,1),%ebp
movslq %ebp,%rbp
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  (%rcx,%rax,8),%xmm1
subsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
lea    (%rsi,%rax,1),%ebp
movslq %ebp,%rbp
subsd  (%r14,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    20e0 <bidiag_orth+0xf60>
jmp    1f40 <bidiag_orth+0xdc0>
nopl   0x0(%rax)
mov    0x8c(%rsp),%eax
mov    %rax,0x40(%rsp)
cmp    0x268(%rsp),%rbx
mov    0x208(%rsp),%r12
mov    0xb0(%rsp),%r15
mov    0x20(%rsp),%r8
mov    0x80(%rsp),%r9
mov    0x228(%rsp),%r11
mov    0x220(%rsp),%r10
mov    0xf8(%rsp),%rbp
jge    1490 <bidiag_orth+0x310>
mov    0x1e0(%rsp),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x78(%rsp)
mov    %rbx,%rax
not    %rax
mov    %rax,0x70(%rsp)
add    %r8,%rax
mov    %rax,0x8(%rsp)
cmp    %r8,%r13
mov    0x128(%rsp),%r9
mov    0x6c(%rsp),%edi
jae    235f <bidiag_orth+0x11df>
mov    0x10(%rsp),%rax
cmpq   $0x4,0x8(%rsp)
jb     22e0 <bidiag_orth+0x1160>
mov    0x18(%rsp),%rax
mov    0x100(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
cmp    %rax,%r12
jae    2201 <bidiag_orth+0x1081>
mov    0x8(%rsp),%rax
lea    (%r12,%rax,8),%rcx
mov    0x198(%rsp),%rax
mov    0x108(%rsp),%rdx
add    %rax,%rdx
mov    0x10(%rsp),%rax
cmp    %rcx,%rdx
jb     22e0 <bidiag_orth+0x1160>
mov    0x118(%rsp),%rax
mov    0x48(%rsp),%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    $0x4,%rax
jae    222a <bidiag_orth+0x10aa>
xor    %edx,%edx
jmp    2279 <bidiag_orth+0x10f9>
mov    0x78(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x8(%rbp,%rdx,8),%xmm0
movups 0x18(%rbp,%rdx,8),%xmm1
movups %xmm0,(%r12,%rdx,8)
movups %xmm1,0x10(%r12,%rdx,8)
movupd 0x28(%rbp,%rdx,8),%xmm0
movupd 0x38(%rbp,%rdx,8),%xmm1
movupd %xmm0,0x20(%r12,%rdx,8)
movupd %xmm1,0x30(%r12,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    2240 <bidiag_orth+0x10c0>
mov    0x8(%rsp),%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%cl
je     22c1 <bidiag_orth+0x1141>
add    0x10(%rsp),%rdx
mov    0xf0(%rsp),%rcx
add    %rdx,%rcx
mov    0x18(%rsp),%rsi
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
mov    0x128(%rsp),%r9
add    0x70(%rsp),%rdx
movupd %xmm0,(%r12,%rdx,8)
movupd %xmm1,0x10(%r12,%rdx,8)
cmp    %rax,0x8(%rsp)
je     235f <bidiag_orth+0x11df>
add    0x10(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r8,%rcx
and    $0x3,%rdx
mov    0x218(%rsp),%rdi
je     2315 <bidiag_orth+0x1195>
nopl   0x0(%rax)
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2300 <bidiag_orth+0x1180>
cmp    $0x3,%rcx
mov    0x6c(%rsp),%edi
jb     235f <bidiag_orth+0x11df>
nop
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r11,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r11,%rax,8)
movsd  0x10(%r10,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  0x18(%r10,%rax,8),%xmm0
movsd  %xmm0,0x8(%r11,%rax,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    2320 <bidiag_orth+0x11a0>
mov    %r9d,%eax
sub    %ebx,%eax
mov    %rax,0x60(%rsp)
mov    0xc8(%rsp),%rsi
add    $0xffffffffffffffff,%rsi
add    $0xffffffff,%edi
mov    %edi,%r13d
mov    %r12,%rdi
mov    %rbx,%rbp
mov    %r9,%rbx
mov    %rsi,0xc8(%rsp)
mov    %r15,%rdx
call   1090 <house@plt>
cmp    0x38(%rsp),%rbp
movsd  %xmm0,0x90(%rsp)
jge    26f0 <bidiag_orth+0x1570>
mov    %r13d,0x6c(%rsp)
mov    0x118(%rsp),%rax
sub    %rbp,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x160(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
mov    0x110(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x140(%rsp)
add    $0x1,%rcx
mov    %rcx,0x158(%rsp)
sub    %rbp,%rbx
mov    %rbx,0xc0(%rsp)
mov    0x8(%rsp),%rax
lea    (%r14,%rax,8),%rcx
mov    %rcx,0xb8(%rsp)
mov    0x258(%rsp),%rcx
sub    %rbp,%rcx
mov    %rcx,0x30(%rsp)
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
mov    0x10(%rsp),%rax
mov    %rcx,0x98(%rsp)
add    %rcx,%rax
mov    %rax,0x150(%rsp)
mov    0x48(%rsp),%r15
mov    0xe8(%rsp),%rdi
mov    0x138(%rsp),%r12
mov    0x1b8(%rsp),%rcx
xor    %r11d,%r11d
xor    %r13d,%r13d
mov    %rbp,%r8
jmp    2497 <bidiag_orth+0x1317>
xchg   %ax,%ax
add    $0x1,%r8
add    $0x1,%r13
add    0x180(%rsp),%r11
mov    0x80(%rsp),%rax
add    %rax,%rcx
mov    0x110(%rsp),%rdx
add    %rdx,%r12
add    %rax,%rdi
add    %rdx,%r15
cmp    0x50(%rsp),%r8
je     2750 <bidiag_orth+0x15d0>
mov    0x20(%rsp),%r10
cmp    %r10,0xa0(%rsp)
jae    2460 <bidiag_orth+0x12e0>
mov    %r8,%r9
imul   %r10,%r9
mov    %r8,%rax
sub    (%rsp),%rax
imul   0xc8(%rsp),%rax
add    0x70(%rsp),%rax
mov    0x10(%rsp),%rbx
cmpq   $0x4,0x8(%rsp)
jb     2650 <bidiag_orth+0x14d0>
mov    0x60(%rsp),%rdx
imul   %r13d,%edx
mov    0x30(%rsp),%rsi
add    %edx,%esi
mov    0x10(%rsp),%rbx
cmp    %edx,%esi
jl     2650 <bidiag_orth+0x14d0>
mov    0x30(%rsp),%rdx
shr    $0x20,%rdx
mov    0x10(%rsp),%rbx
jne    2650 <bidiag_orth+0x14d0>
mov    %r13,%rdx
imul   %r10,%rdx
mov    0xc0(%rsp),%rsi
imul   %r13d,%esi
mov    0x18(%rsp),%rbp
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
mov    0x108(%rsp),%rbp
lea    0x8(%rbp,%rbx,1),%rbp
movslq %esi,%rsi
mov    0xb8(%rsp),%rbx
lea    (%rbx,%rsi,8),%rbx
cmp    %rbx,%rbp
jae    2572 <bidiag_orth+0x13f2>
add    0x100(%rsp),%rdx
mov    0x18(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
lea    (%r14,%rsi,8),%rsi
mov    0x10(%rsp),%rbx
cmp    %rdx,%rsi
jb     2650 <bidiag_orth+0x14d0>
cmpq   $0x4,0x160(%rsp)
jae    2581 <bidiag_orth+0x1401>
xor    %ebx,%ebx
jmp    25f2 <bidiag_orth+0x1472>
mov    0x78(%rsp),%rsi
mov    %r11,%rbp
xor    %ebx,%ebx
movabs $0x800000000,%r10
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rcx,%rbx,8),%xmm0
movups -0x20(%rcx,%rbx,8),%xmm1
mov    %rbp,%rdx
sar    $0x1d,%rdx
movups %xmm0,(%r14,%rdx,1)
movups %xmm1,0x10(%r14,%rdx,1)
movupd -0x10(%rcx,%rbx,8),%xmm0
movupd (%rcx,%rbx,8),%xmm1
movabs $0x400000000,%rdx
add    %rbp,%rdx
sar    $0x1d,%rdx
movupd %xmm0,(%r14,%rdx,1)
movupd %xmm1,0x10(%r14,%rdx,1)
add    $0x8,%rbx
add    %r10,%rbp
add    $0xfffffffffffffffe,%rsi
jne    25a0 <bidiag_orth+0x1420>
testb  $0x1,0x158(%rsp)
01
je     2627 <bidiag_orth+0x14a7>
add    0x10(%rsp),%rbx
lea    (%rbx,%r9,1),%rdx
mov    0x18(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
add    %eax,%ebx
movslq %ebx,%rdx
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
mov    0x150(%rsp),%rbx
mov    0x98(%rsp),%rdx
cmp    %rdx,0x8(%rsp)
mov    0x20(%rsp),%r10
je     2460 <bidiag_orth+0x12e0>
nopw   0x0(%rax,%rax,1)
mov    %r10d,%edx
sub    %ebx,%edx
mov    %rbx,%r10
test   $0x1,%dl
je     267a <bidiag_orth+0x14fa>
add    %rbx,%r9
mov    0x18(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm0
add    %ebx,%eax
movslq %eax,%rdx
movsd  %xmm0,(%r14,%rdx,8)
lea    0x1(%rbx),%r10
not    %rbx
cmp    0x230(%rsp),%rbx
movabs $0x200000000,%rbp
mov    0x20(%rsp),%rax
je     2460 <bidiag_orth+0x12e0>
lea    (%r10,%r12,1),%ebx
shl    $0x20,%rbx
lea    (%r15,%r10,1),%edx
shl    $0x20,%rdx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%r10,8),%xmm0
mov    %rbx,%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  (%rdi,%r10,8),%xmm0
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
add    $0x2,%r10
add    %rbp,%rbx
add    %rbp,%rdx
cmp    %r10,%rax
jne    26b0 <bidiag_orth+0x1530>
jmp    2460 <bidiag_orth+0x12e0>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r15,%rsi
mov    0xa8(%rsp),%rbx
mov    %rbx,%rdx
mov    0x28(%rsp),%ebp
mov    %ebp,%ecx
mov    %r13d,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    $0x1,%edx
movsd  0x90(%rsp),%xmm0
call   1080 <scale@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %ebp,%ecx
mov    $0x1,%r8d
mov    %r13d,%r9d
call   1040 <mmult@plt>
jmp    2a40 <bidiag_orth+0x18c0>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    0xb0(%rsp),%r15
mov    %r15,%rsi
mov    0xa8(%rsp),%rbx
mov    %rbx,%rdx
mov    0x28(%rsp),%ebp
mov    %ebp,%ecx
mov    0x6c(%rsp),%r12d
mov    %r12d,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    $0x1,%edx
movsd  0x90(%rsp),%xmm0
call   1080 <scale@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %ebp,%ecx
mov    $0x1,%r8d
mov    %r12d,%r9d
call   1040 <mmult@plt>
mov    (%rsp),%rax
cmp    0x38(%rsp),%rax
jge    2a40 <bidiag_orth+0x18c0>
mov    0x10(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x28(%rsp)
mov    0xe8(%rsp),%rcx
mov    0x48(%rsp),%r10
mov    0x138(%rsp),%r11
mov    0x1b0(%rsp),%rdi
xor    %r9d,%r9d
xor    %r12d,%r12d
mov    (%rsp),%r13
jmp    2837 <bidiag_orth+0x16b7>
add    $0x1,%r13
add    $0x1,%r12
add    0x180(%rsp),%r9
mov    0x80(%rsp),%rax
add    %rax,%rdi
mov    0x110(%rsp),%rdx
add    %rdx,%r11
add    %rdx,%r10
add    %rax,%rcx
cmp    0x50(%rsp),%r13
je     2a40 <bidiag_orth+0x18c0>
mov    0x20(%rsp),%rbp
cmp    %rbp,0xa0(%rsp)
jae    2800 <bidiag_orth+0x1680>
mov    0x10(%rsp),%rdx
cmpq   $0x4,0x8(%rsp)
jb     2970 <bidiag_orth+0x17f0>
mov    0x60(%rsp),%rsi
imul   %r12d,%esi
mov    0x30(%rsp),%rax
lea    (%rsi,%rax,1),%ebx
mov    0x10(%rsp),%rdx
cmp    %esi,%ebx
jl     2970 <bidiag_orth+0x17f0>
mov    0x30(%rsp),%rdx
shr    $0x20,%rdx
mov    0x10(%rsp),%rdx
jne    2970 <bidiag_orth+0x17f0>
mov    %r12,%rdx
imul   %rbp,%rdx
mov    0xc0(%rsp),%rax
mov    %eax,%esi
imul   %r12d,%esi
mov    0x18(%rsp),%rax
lea    (%rax,%rdx,8),%rbx
mov    0x108(%rsp),%rax
lea    (%rax,%rbx,1),%r15
add    $0x8,%r15
movslq %esi,%rsi
mov    0xb8(%rsp),%rax
lea    (%rax,%rsi,8),%rbx
cmp    %rbx,%r15
mov    0xb0(%rsp),%r15
jae    28f2 <bidiag_orth+0x1772>
add    0x100(%rsp),%rdx
mov    0x18(%rsp),%rax
lea    (%rax,%rdx,8),%rbx
lea    (%r14,%rsi,8),%rsi
mov    0x10(%rsp),%rdx
cmp    %rbx,%rsi
jb     2970 <bidiag_orth+0x17f0>
mov    %r9,%rdx
xor    %esi,%esi
movabs $0x400000000,%rax
mov    0x140(%rsp),%rbp
nopl   0x0(%rax)
mov    %rdx,%rbx
sar    $0x1d,%rbx
movupd (%r14,%rbx,1),%xmm0
movupd 0x10(%r14,%rbx,1),%xmm1
movupd -0x10(%rdi,%rsi,8),%xmm2
subpd  %xmm0,%xmm2
movupd (%rdi,%rsi,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rdi,%rsi,8)
movupd %xmm0,(%rdi,%rsi,8)
add    $0x4,%rsi
add    %rax,%rdx
cmp    %rsi,%rbp
jne    2910 <bidiag_orth+0x1790>
mov    0x28(%rsp),%rdx
mov    0x98(%rsp),%rax
cmp    %rax,0x8(%rsp)
mov    0x20(%rsp),%rbp
je     2800 <bidiag_orth+0x1680>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%esi
sub    %edx,%esi
mov    %rdx,%rbx
test   $0x1,%sil
je     29ba <bidiag_orth+0x183a>
mov    %r13,%rsi
imul   %rbp,%rsi
mov    %r13,%rbx
sub    (%rsp),%rbx
imul   0xc8(%rsp),%rbx
add    0x70(%rsp),%rbx
add    %edx,%ebx
movslq %ebx,%rbx
add    %rdx,%rsi
mov    0x18(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm0
subsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
lea    0x1(%rdx),%rbx
not    %rdx
cmp    0x230(%rsp),%rdx
movabs $0x200000000,%r8
je     2800 <bidiag_orth+0x1680>
lea    (%rbx,%r11,1),%eax
shl    $0x20,%rax
lea    (%r10,%rbx,1),%esi
shl    $0x20,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rdx
sar    $0x1d,%rdx
movsd  -0x8(%rcx,%rbx,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm1
subsd  (%r14,%rdx,1),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbx,8)
mov    %rsi,%rdx
sar    $0x1d,%rdx
subsd  (%r14,%rdx,1),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x2,%rbx
add    %r8,%rax
add    %r8,%rsi
cmp    %rbx,%rbp
jne    29f0 <bidiag_orth+0x1870>
jmp    2800 <bidiag_orth+0x1680>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%rax
add    $0x2,%rax
mov    0x20(%rsp),%r8
cmp    %r8,%rax
mov    0x208(%rsp),%r12
mov    0x80(%rsp),%r9
mov    0x228(%rsp),%r11
mov    0x220(%rsp),%r10
mov    0xf8(%rsp),%rbp
mov    0xa0(%rsp),%r13
jae    1490 <bidiag_orth+0x310>
movslq 0xd4(%rsp),%rax
mov    0x60(%rsp),%rbx
lea    -0x1(%rbx),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     2bd0 <bidiag_orth+0x1a50>
mov    0xf0(%rsp),%rsi
add    %rax,%rsi
mov    0x18(%rsp),%rdi
lea    (%rdi,%rsi,8),%rdi
lea    (%r15,%rbx,8),%rbp
cmp    %rbp,%rdi
jae    2ae9 <bidiag_orth+0x1969>
add    %rbx,%rsi
mov    0x248(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
cmp    %rsi,0x240(%rsp)
jae    2ae9 <bidiag_orth+0x1969>
mov    0xf8(%rsp),%rbp
jmp    2bd0 <bidiag_orth+0x1a50>
lea    -0x5(%rbx),%rsi
mov    %rsi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    $0x4,%rsi
jae    2b02 <bidiag_orth+0x1982>
xor    %esi,%esi
jmp    2b6a <bidiag_orth+0x19ea>
mov    0x40(%rsp),%rsi
lea    -0x5(%rsi),%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x130(%rsp),%rsi
lea    (%rsi,%rax,8),%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x8(%r15,%rsi,8),%xmm0
movups 0x18(%r15,%rsi,8),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,8)
movups %xmm1,0x0(%rbp,%rsi,8)
movupd 0x28(%r15,%rsi,8),%xmm0
movupd 0x38(%r15,%rsi,8),%xmm1
movupd %xmm0,0x10(%rbp,%rsi,8)
movupd %xmm1,0x20(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2b30 <bidiag_orth+0x19b0>
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
test   $0x1,%cl
je     2baa <bidiag_orth+0x1a2a>
lea    0x0(,%rsi,8),%rcx
add    %rax,%rsi
or     $0x8,%rcx
movupd (%r15,%rcx,1),%xmm0
movupd 0x10(%r15,%rcx,1),%xmm1
add    0xf0(%rsp),%rsi
mov    0x18(%rsp),%rcx
movupd %xmm0,(%rcx,%rsi,8)
movupd %xmm1,0x10(%rcx,%rsi,8)
cmp    %rdi,%rdx
mov    0xf8(%rsp),%rbp
je     1490 <bidiag_orth+0x310>
lea    0x1(%rdi),%rcx
add    %rdi,%rax
mov    0x60(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %ebx,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%sil
je     2c1a <bidiag_orth+0x1a9a>
mov    0x8c(%rsp),%esi
sub    %cl,%sil
movzbl %sil,%esi
and    $0x3,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
add    $0x1,%rcx
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    2c00 <bidiag_orth+0x1a80>
cmp    $0x3,%rdx
jb     1490 <bidiag_orth+0x310>
mov    0x40(%rsp),%rdx
sub    %rcx,%rdx
mov    0x250(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
add    0x1a8(%rsp),%rax
mov    0x18(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rsi,8)
movsd  -0x10(%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rsi,8)
movsd  -0x8(%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    2c50 <bidiag_orth+0x1ad0>
jmp    1490 <bidiag_orth+0x310>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    0x344(%rip),%rdi
call   1050 <printf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>

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

LLVM IR (-O2):
@.str = [39 x i8] c"M should be greater than or equal to N\00"
define void @bidiag_orth(double* nocapture %0, i32 %1, i32 %2, double* %3, double* %4) {
%6 = icmp slt i32 %1, %2
br i1 %6, label %7, label %10
7: ; preds = %5
%8 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
%9 = tail call i32 @exit(i32 1)
unreachable
10: ; preds = %5
%11 = shl i32 %1, 3
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = inttoptr i64 %12 to i8*
%15 = tail call i64 @malloc(i32 %11)
%16 = inttoptr i64 %15 to double*
%17 = mul i32 %11, %1
%18 = tail call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to double*
%20 = tail call i64 @malloc(i32 %17)
%21 = inttoptr i64 %20 to double*
%22 = tail call i32 @eye(double* %3, i32 %1)
%23 = tail call i32 @eye(double* %4, i32 %2)
%24 = icmp sgt i32 %2, 0
br i1 %24, label %25, label %1125
25: ; preds = %10
%26 = add nsw i32 %2, -2
%27 = zext i32 %2 to i64
%28 = sext i32 %1 to i64
%29 = sext i32 %26 to i64
%30 = zext i32 %2 to i64
%31 = zext i32 %1 to i64
%32 = zext i32 %1 to i64
%33 = zext i32 %1 to i64
%34 = zext i32 %1 to i64
%35 = zext i32 %1 to i64
%36 = zext i32 %1 to i64
%37 = zext i32 %1 to i64
%38 = zext i32 %1 to i64
%39 = getelementptr double, double* %0, i64 -1
%40 = add i32 %2, -1
%41 = getelementptr double, double* %16, i64 1
%42 = add nsw i64 %30, -2
%43 = shl nuw nsw i64 %30, 3
%44 = add nuw nsw i64 %43, 8
%45 = add i32 %2, -1
%46 = zext i32 %45 to i64
%47 = add nsw i64 %30, -2
%48 = shl nuw nsw i64 %30, 3
%49 = add nuw nsw i64 %48, 8
%50 = add i32 %2, -1
%51 = zext i32 %50 to i64
%52 = getelementptr double, double* %0, i64 1
%53 = bitcast double* %52 to i8*
%54 = shl nuw nsw i64 %30, 3
%55 = add nuw nsw i64 %54, 8
%56 = add nsw i64 %31, -1
%57 = shl nsw i64 %28, 3
%58 = add nsw i64 %57, 8
%59 = add nsw i64 %31, -1
%60 = shl nsw i64 %28, 3
%61 = add nsw i64 %60, 8
%62 = add nsw i64 %30, -1
%63 = shl nuw nsw i64 %30, 3
%64 = add nuw nsw i64 %63, 8
%65 = add nsw i64 %30, -1
%66 = sub nsw i64 0, %38
%67 = sub nsw i64 0, %38
%68 = sub nsw i64 0, %30
%69 = sub nsw i64 0, %30
br label %70
70: ; preds = %25, %1119
%71 = phi i64 [ 0, %25 ], [ %1120, %1119 ]
%72 = phi i32 [ %2, %25 ], [ %169, %1119 ]
%73 = phi i32 [ 2, %25 ], [ %1123, %1119 ]
%74 = phi i64 [ 1, %25 ], [ %1122, %1119 ]
%75 = phi i32 [ %1, %25 ], [ %1121, %1119 ]
%76 = phi i64 [ 0, %25 ], [ %331, %1119 ]
%77 = trunc i64 %76 to i32
%78 = sub i32 %45, %77
%79 = zext i32 %78 to i64
%80 = trunc i64 %76 to i32
%81 = sub i32 %45, %80
%82 = zext i32 %81 to i64
%83 = add nsw i64 %82, -5
%84 = lshr i64 %83, 2
%85 = add nuw nsw i64 %84, 1
%86 = sub i64 %65, %76
%87 = add i64 %86, -4
%88 = lshr i64 %87, 2
%89 = add nuw nsw i64 %88, 1
%90 = add i64 %65, %71
%91 = add i64 %90, -4
%92 = lshr i64 %91, 2
%93 = add nuw nsw i64 %92, 1
%94 = add i64 %71, %38
%95 = add i64 %94, -4
%96 = lshr i64 %95, 2
%97 = add nuw nsw i64 %96, 1
%98 = add i64 %71, %30
%99 = mul i64 %64, %76
%100 = mul i64 %76, %30
%101 = add i64 %100, %30
%102 = add i64 %71, %30
%103 = getelementptr double, double* %19, i64 %102
%104 = add i64 %62, %71
%105 = add i64 %71, %31
%106 = mul i64 %61, %76
%107 = mul i64 %76, %28
%108 = add i64 %107, %31
%109 = add i64 %71, %31
%110 = getelementptr double, double* %19, i64 %109
%111 = add i64 %59, %71
%112 = add i64 %71, %31
%113 = mul i64 %58, %76
%114 = mul i64 %76, %28
%115 = add i64 %114, %31
%116 = add i64 %71, %31
%117 = getelementptr double, double* %19, i64 %116
%118 = add i64 %56, %71
%119 = xor i64 %76, -1
%120 = add nsw i64 %119, %30
%121 = xor i64 %76, -1
%122 = add nsw i64 %121, %30
%123 = getelementptr double, double* %13, i64 %122
%124 = bitcast double* %123 to i8*
%125 = mul i64 %55, %76
%126 = getelementptr i8, i8* %53, i64 %125
%127 = mul i64 %76, %30
%128 = add i64 %127, %30
%129 = getelementptr double, double* %0, i64 %128
%130 = bitcast double* %129 to i8*
%131 = xor i64 %76, -1
%132 = add nsw i64 %131, %30
%133 = mul i64 %49, %76
%134 = mul i64 %76, %30
%135 = add i64 %134, %30
%136 = sub nsw i64 %51, %76
%137 = xor i64 %76, -1
%138 = add nsw i64 %137, %30
%139 = getelementptr double, double* %19, i64 %138
%140 = sub i64 %47, %76
%141 = trunc i64 %76 to i32
%142 = sub i32 %45, %141
%143 = xor i64 %76, -1
%144 = add nsw i64 %143, %30
%145 = mul i64 %44, %76
%146 = mul i64 %76, %30
%147 = add i64 %146, %30
%148 = sub nsw i64 %46, %76
%149 = xor i64 %76, -1
%150 = add nsw i64 %149, %30
%151 = getelementptr double, double* %19, i64 %150
%152 = sub i64 %42, %76
%153 = trunc i64 %76 to i32
%154 = sub i32 %40, %153
%155 = trunc i64 %76 to i32
%156 = sub i32 %40, %155
%157 = zext i32 %156 to i64
%158 = add nsw i64 %157, -1
%159 = mul i64 %76, %30
%160 = sext i32 %73 to i64
%161 = add i64 %159, %160
%162 = getelementptr double, double* %0, i64 %161
%163 = trunc i64 %76 to i32
%164 = sub i32 %40, %163
%165 = zext i32 %164 to i64
%166 = add i64 %161, %165
%167 = getelementptr double, double* %39, i64 %166
%168 = getelementptr double, double* %16, i64 %165
%169 = add i32 %72, -1
%170 = trunc i64 %76 to i32
%171 = sext i32 %73 to i64
%172 = zext i32 %75 to i64
%173 = icmp slt i64 %76, %28
br i1 %173, label %178, label %174
174: ; preds = %70
%175 = trunc i64 %76 to i32
%176 = sub i32 %1, %175
%177 = tail call double @house(double* %13, i32 %176, double* %16)
br label %212
178: ; preds = %70, %178
%179 = phi i64 [ %186, %178 ], [ %76, %70 ]
%180 = mul nsw i64 %179, %27
%181 = add nuw nsw i64 %180, %76
%182 = getelementptr inbounds double, double* %0, i64 %181
%183 = load double, double* %182
%184 = sub nuw nsw i64 %179, %76
%185 = getelementptr inbounds double, double* %13, i64 %184
store double %183, double* %185
%186 = add nuw nsw i64 %179, 1
%187 = icmp eq i64 %186, %31
br i1 %187, label %188, label %178
188: ; preds = %178
%189 = trunc i64 %76 to i32
%190 = sub i32 %1, %189
%191 = tail call double @house(double* %13, i32 %190, double* %16)
br i1 %173, label %192, label %212
192: ; preds = %188, %209
%193 = phi i64 [ %210, %209 ], [ %76, %188 ]
%194 = mul nsw i64 %193, %27
%195 = add nsw i64 %193, %71
br label %196
196: ; preds = %192, %196
%197 = phi i64 [ 0, %192 ], [ %206, %196 ]
%198 = phi i64 [ %76, %192 ], [ %207, %196 ]
%199 = add nuw nsw i64 %198, %194
%200 = getelementptr inbounds double, double* %0, i64 %199
%201 = load double, double* %200
%202 = add i64 %195, %197
%203 = shl i64 %202, 32
%204 = ashr exact i64 %203, 32
%205 = getelementptr inbounds double, double* %19, i64 %204
store double %201, double* %205
%206 = add i64 %197, %172
%207 = add nuw nsw i64 %198, 1
%208 = icmp eq i64 %207, %30
br i1 %208, label %209, label %196
209: ; preds = %196
%210 = add nuw nsw i64 %193, 1
%211 = icmp eq i64 %210, %32
br i1 %211, label %212, label %192
212: ; preds = %209, %174, %188
%213 = phi double [ %177, %174 ], [ %191, %188 ], [ %191, %209 ]
%214 = phi i32 [ %176, %174 ], [ %190, %188 ], [ %190, %209 ]
%215 = sub nsw i64 %27, %76
%216 = sub nsw i32 %2, %170
%217 = tail call i32 @mmult(double* %19, double* %16, double* %21, i32 %216, i32 %214, i32 1)
%218 = trunc i64 %215 to i32
%219 = tail call i32 @scale(double* %21, i32 %218, i32 1, double %213)
%220 = tail call i32 @mmult(double* %16, double* %21, double* %19, i32 %214, i32 1, i32 %216)
br i1 %173, label %221, label %330
221: ; preds = %212
%222 = icmp ult i64 %98, 4
%223 = trunc i64 %104 to i32
%224 = icmp ugt i64 %104, 4294967295
%225 = and i64 %98, -4
%226 = add i64 %76, %225
%227 = icmp eq i64 %98, %225
br label %228
228: ; preds = %221, %325
%229 = phi i64 [ %329, %325 ], [ 0, %221 ]
%230 = phi i32 [ %328, %325 ], [ 0, %221 ]
%231 = phi i64 [ %326, %325 ], [ %76, %221 ]
%232 = mul i64 %229, %30
%233 = getelementptr double, double* %0, i64 %232
%234 = bitcast double* %233 to i8*
%235 = getelementptr i8, i8* %234, i64 %99
%236 = add i64 %101, %232
%237 = getelementptr double, double* %0, i64 %236
%238 = mul i64 %102, %229
%239 = shl i64 %238, 32
%240 = ashr exact i64 %239, 32
%241 = getelementptr double, double* %19, i64 %240
%242 = getelementptr double, double* %103, i64 %240
%243 = bitcast double* %242 to i8*
%244 = mul i32 %72, %230
%245 = mul nsw i64 %231, %27
%246 = sub nsw i64 %231, %76
%247 = mul i64 %246, %215
%248 = add i64 %247, %71
br i1 %222, label %283, label %249
249: ; preds = %228
%250 = add i32 %244, %223
%251 = icmp slt i32 %250, %244
%252 = or i1 %251, %224
br i1 %252, label %283, label %253
253: ; preds = %249
%254 = icmp ult i8* %235, %243
%255 = icmp ult double* %241, %237
%256 = and i1 %254, %255
br i1 %256, label %283, label %257
257: ; preds = %253, %257
%258 = phi i64 [ %280, %257 ], [ 0, %253 ]
%259 = add i64 %76, %258
%260 = add i64 %248, %259
%261 = shl i64 %260, 32
%262 = ashr exact i64 %261, 32
%263 = getelementptr inbounds double, double* %19, i64 %262
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = getelementptr inbounds double, double* %263, i64 2
%267 = bitcast double* %266 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = add nuw nsw i64 %259, %245
%270 = getelementptr inbounds double, double* %0, i64 %269
%271 = bitcast double* %270 to <2 x double>*
%272 = load <2 x double>, <2 x double>* %271
%273 = getelementptr inbounds double, double* %270, i64 2
%274 = bitcast double* %273 to <2 x double>*
%275 = load <2 x double>, <2 x double>* %274
%276 = fsub <2 x double> %272, %265
%277 = fsub <2 x double> %275, %268
%278 = bitcast double* %270 to <2 x double>*
store <2 x double> %276, <2 x double>* %278
%279 = bitcast double* %273 to <2 x double>*
store <2 x double> %277, <2 x double>* %279
%280 = add nuw i64 %258, 4
%281 = icmp eq i64 %280, %225
br i1 %281, label %282, label %257
282: ; preds = %257
br i1 %227, label %325, label %283
283: ; preds = %253, %249, %228, %282
%284 = phi i64 [ %76, %253 ], [ %76, %249 ], [ %76, %228 ], [ %226, %282 ]
%285 = sub i64 %30, %284
%286 = and i64 %285, 1
%287 = icmp eq i64 %286, 0
br i1 %287, label %299, label %288
288: ; preds = %283
%289 = add i64 %248, %284
%290 = shl i64 %289, 32
%291 = ashr exact i64 %290, 32
%292 = getelementptr inbounds double, double* %19, i64 %291
%293 = load double, double* %292
%294 = add nuw nsw i64 %284, %245
%295 = getelementptr inbounds double, double* %0, i64 %294
%296 = load double, double* %295
%297 = fsub double %296, %293
store double %297, double* %295
%298 = add nuw nsw i64 %284, 1
br label %299
299: ; preds = %288, %283
%300 = phi i64 [ %284, %283 ], [ %298, %288 ]
%301 = icmp eq i64 %65, %284
br i1 %301, label %325, label %302
302: ; preds = %299, %302
%303 = phi i64 [ %323, %302 ], [ %300, %299 ]
%304 = add i64 %248, %303
%305 = shl i64 %304, 32
%306 = ashr exact i64 %305, 32
%307 = getelementptr inbounds double, double* %19, i64 %306
%308 = load double, double* %307
%309 = add nuw nsw i64 %303, %245
%310 = getelementptr inbounds double, double* %0, i64 %309
%311 = load double, double* %310
%312 = fsub double %311, %308
store double %312, double* %310
%313 = add nuw nsw i64 %303, 1
%314 = add i64 %248, %313
%315 = shl i64 %314, 32
%316 = ashr exact i64 %315, 32
%317 = getelementptr inbounds double, double* %19, i64 %316
%318 = load double, double* %317
%319 = add nuw nsw i64 %313, %245
%320 = getelementptr inbounds double, double* %0, i64 %319
%321 = load double, double* %320
%322 = fsub double %321, %318
store double %322, double* %320
%323 = add nuw nsw i64 %303, 2
%324 = icmp eq i64 %323, %30
br i1 %324, label %325, label %302
325: ; preds = %299, %302, %282
%326 = add nuw nsw i64 %231, 1
%327 = icmp eq i64 %326, %33
%328 = add i32 %230, 1
%329 = add i64 %229, 1
br i1 %327, label %330, label %228
330: ; preds = %325, %212
%331 = add nuw nsw i64 %76, 1
%332 = icmp slt i64 %331, %28
br i1 %332, label %346, label %333
333: ; preds = %346, %330
br i1 %173, label %334, label %605
334: ; preds = %333
%335 = trunc i64 %71 to i32
%336 = icmp ult i64 %105, 4
%337 = trunc i64 %111 to i32
%338 = icmp ugt i64 %111, 4294967295
%339 = and i64 %105, -4
%340 = add i64 %76, %339
%341 = and i64 %97, 1
%342 = icmp ult i64 %95, 4
%343 = and i64 %97, 9223372036854775806
%344 = icmp eq i64 %341, 0
%345 = icmp eq i64 %105, %339
br label %356
346: ; preds = %330, %346
%347 = phi i64 [ %354, %346 ], [ %74, %330 ]
%348 = sub nuw nsw i64 %347, %76
%349 = getelementptr inbounds double, double* %16, i64 %348
%350 = load double, double* %349
%351 = mul nsw i64 %347, %27
%352 = add nuw nsw i64 %351, %76
%353 = getelementptr inbounds double, double* %0, i64 %352
store double %350, double* %353
%354 = add nuw nsw i64 %347, 1
%355 = icmp eq i64 %354, %34
br i1 %355, label %333, label %346
356: ; preds = %483, %334
%357 = phi i64 [ %487, %483 ], [ 0, %334 ]
%358 = phi i32 [ %486, %483 ], [ 0, %334 ]
%359 = phi i64 [ %484, %483 ], [ %76, %334 ]
%360 = mul i64 %357, %28
%361 = getelementptr double, double* %3, i64 %360
%362 = bitcast double* %361 to i8*
%363 = getelementptr i8, i8* %362, i64 %106
%364 = add i64 %108, %360
%365 = getelementptr double, double* %3, i64 %364
%366 = trunc i64 %357 to i32
%367 = mul i32 %214, %366
%368 = sext i32 %367 to i64
%369 = getelementptr double, double* %19, i64 %368
%370 = getelementptr double, double* %110, i64 %368
%371 = bitcast double* %370 to i8*
%372 = mul i32 %214, %358
%373 = mul nsw i64 %359, %28
%374 = trunc i64 %359 to i32
%375 = sub nuw nsw i32 %374, %170
%376 = mul nsw i32 %375, %214
%377 = add i32 %376, %335
br i1 %336, label %446, label %378
378: ; preds = %356
%379 = add i32 %372, %337
%380 = icmp slt i32 %379, %372
%381 = or i1 %380, %338
br i1 %381, label %446, label %382
382: ; preds = %378
%383 = icmp ult i8* %363, %371
%384 = icmp ult double* %369, %365
%385 = and i1 %383, %384
br i1 %385, label %446, label %386
386: ; preds = %382
br i1 %342, label %426, label %387
387: ; preds = %386, %387
%388 = phi i64 [ %423, %387 ], [ 0, %386 ]
%389 = phi i64 [ %424, %387 ], [ 0, %386 ]
%390 = add i64 %76, %388
%391 = add i64 %76, %388
%392 = trunc i64 %391 to i32
%393 = add nsw i64 %390, %373
%394 = getelementptr inbounds double, double* %3, i64 %393
%395 = bitcast double* %394 to <2 x double>*
%396 = load <2 x double>, <2 x double>* %395
%397 = getelementptr inbounds double, double* %394, i64 2
%398 = bitcast double* %397 to <2 x double>*
%399 = load <2 x double>, <2 x double>* %398
%400 = add i32 %377, %392
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %19, i64 %401
%403 = bitcast double* %402 to <2 x double>*
store <2 x double> %396, <2 x double>* %403
%404 = getelementptr inbounds double, double* %402, i64 2
%405 = bitcast double* %404 to <2 x double>*
store <2 x double> %399, <2 x double>* %405
%406 = or i64 %388, 4
%407 = add i64 %76, %406
%408 = add i64 %76, %406
%409 = trunc i64 %408 to i32
%410 = add nsw i64 %407, %373
%411 = getelementptr inbounds double, double* %3, i64 %410
%412 = bitcast double* %411 to <2 x double>*
%413 = load <2 x double>, <2 x double>* %412
%414 = getelementptr inbounds double, double* %411, i64 2
%415 = bitcast double* %414 to <2 x double>*
%416 = load <2 x double>, <2 x double>* %415
%417 = add i32 %377, %409
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %19, i64 %418
%420 = bitcast double* %419 to <2 x double>*
store <2 x double> %413, <2 x double>* %420
%421 = getelementptr inbounds double, double* %419, i64 2
%422 = bitcast double* %421 to <2 x double>*
store <2 x double> %416, <2 x double>* %422
%423 = add nuw i64 %388, 8
%424 = add i64 %389, 2
%425 = icmp eq i64 %424, %343
br i1 %425, label %426, label %387
426: ; preds = %387, %386
%427 = phi i64 [ 0, %386 ], [ %423, %387 ]
br i1 %344, label %445, label %428
428: ; preds = %426
%429 = add i64 %76, %427
%430 = add i64 %76, %427
%431 = trunc i64 %430 to i32
%432 = add nsw i64 %429, %373
%433 = getelementptr inbounds double, double* %3, i64 %432
%434 = bitcast double* %433 to <2 x double>*
%435 = load <2 x double>, <2 x double>* %434
%436 = getelementptr inbounds double, double* %433, i64 2
%437 = bitcast double* %436 to <2 x double>*
%438 = load <2 x double>, <2 x double>* %437
%439 = add i32 %377, %431
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %19, i64 %440
%442 = bitcast double* %441 to <2 x double>*
store <2 x double> %435, <2 x double>* %442
%443 = getelementptr inbounds double, double* %441, i64 2
%444 = bitcast double* %443 to <2 x double>*
store <2 x double> %438, <2 x double>* %444
br label %445
445: ; preds = %426, %428
br i1 %345, label %483, label %446
446: ; preds = %382, %378, %356, %445
%447 = phi i64 [ %76, %382 ], [ %76, %378 ], [ %76, %356 ], [ %340, %445 ]
%448 = sub i64 %38, %447
%449 = xor i64 %447, -1
%450 = and i64 %448, 1
%451 = icmp eq i64 %450, 0
br i1 %451, label %461, label %452
452: ; preds = %446
%453 = add nsw i64 %447, %373
%454 = getelementptr inbounds double, double* %3, i64 %453
%455 = load double, double* %454
%456 = trunc i64 %447 to i32
%457 = add i32 %377, %456
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds double, double* %19, i64 %458
store double %455, double* %459
%460 = add nuw nsw i64 %447, 1
br label %461
461: ; preds = %452, %446
%462 = phi i64 [ %447, %446 ], [ %460, %452 ]
%463 = icmp eq i64 %449, %66
br i1 %463, label %483, label %464
464: ; preds = %461, %464
%465 = phi i64 [ %481, %464 ], [ %462, %461 ]
%466 = add nsw i64 %465, %373
%467 = getelementptr inbounds double, double* %3, i64 %466
%468 = load double, double* %467
%469 = trunc i64 %465 to i32
%470 = add i32 %377, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %19, i64 %471
store double %468, double* %472
%473 = add nuw nsw i64 %465, 1
%474 = add nsw i64 %473, %373
%475 = getelementptr inbounds double, double* %3, i64 %474
%476 = load double, double* %475
%477 = trunc i64 %473 to i32
%478 = add i32 %377, %477
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %19, i64 %479
store double %476, double* %480
%481 = add nuw nsw i64 %465, 2
%482 = icmp eq i64 %481, %35
br i1 %482, label %483, label %464
483: ; preds = %461, %464, %445
%484 = add nuw nsw i64 %359, 1
%485 = icmp eq i64 %484, %35
%486 = add i32 %358, 1
%487 = add i64 %357, 1
br i1 %485, label %488, label %356
488: ; preds = %483
%489 = tail call i32 @mmult(double* %19, double* %16, double* %21, i32 %214, i32 %214, i32 1)
%490 = tail call i32 @scale(double* %21, i32 %214, i32 1, double %213)
%491 = tail call i32 @mmult(double* %21, double* %16, double* %19, i32 %214, i32 1, i32 %214)
br i1 %173, label %492, label %609
492: ; preds = %488
%493 = trunc i64 %71 to i32
%494 = icmp ult i64 %112, 4
%495 = trunc i64 %118 to i32
%496 = icmp ugt i64 %118, 4294967295
%497 = and i64 %112, -4
%498 = add i64 %76, %497
%499 = icmp eq i64 %112, %497
br label %500
500: ; preds = %600, %492
%501 = phi i64 [ %604, %600 ], [ 0, %492 ]
%502 = phi i32 [ %603, %600 ], [ 0, %492 ]
%503 = phi i64 [ %601, %600 ], [ %76, %492 ]
%504 = mul i64 %501, %28
%505 = getelementptr double, double* %3, i64 %504
%506 = bitcast double* %505 to i8*
%507 = getelementptr i8, i8* %506, i64 %113
%508 = add i64 %115, %504
%509 = getelementptr double, double* %3, i64 %508
%510 = trunc i64 %501 to i32
%511 = mul i32 %214, %510
%512 = sext i32 %511 to i64
%513 = getelementptr double, double* %19, i64 %512
%514 = getelementptr double, double* %117, i64 %512
%515 = bitcast double* %514 to i8*
%516 = mul i32 %214, %502
%517 = mul nsw i64 %503, %28
%518 = trunc i64 %503 to i32
%519 = sub nuw nsw i32 %518, %170
%520 = mul nsw i32 %519, %214
%521 = add i32 %520, %493
br i1 %494, label %557, label %522
522: ; preds = %500
%523 = add i32 %516, %495
%524 = icmp slt i32 %523, %516
%525 = or i1 %524, %496
br i1 %525, label %557, label %526
526: ; preds = %522
%527 = icmp ult i8* %507, %515
%528 = icmp ult double* %513, %509
%529 = and i1 %527, %528
br i1 %529, label %557, label %530
530: ; preds = %526, %530
%531 = phi i64 [ %554, %530 ], [ 0, %526 ]
%532 = add i64 %76, %531
%533 = add i64 %76, %531
%534 = trunc i64 %533 to i32
%535 = add i32 %521, %534
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double, double* %19, i64 %536
%538 = bitcast double* %537 to <2 x double>*
%539 = load <2 x double>, <2 x double>* %538
%540 = getelementptr inbounds double, double* %537, i64 2
%541 = bitcast double* %540 to <2 x double>*
%542 = load <2 x double>, <2 x double>* %541
%543 = add nsw i64 %532, %517
%544 = getelementptr inbounds double, double* %3, i64 %543
%545 = bitcast double* %544 to <2 x double>*
%546 = load <2 x double>, <2 x double>* %545
%547 = getelementptr inbounds double, double* %544, i64 2
%548 = bitcast double* %547 to <2 x double>*
%549 = load <2 x double>, <2 x double>* %548
%550 = fsub <2 x double> %546, %539
%551 = fsub <2 x double> %549, %542
%552 = bitcast double* %544 to <2 x double>*
store <2 x double> %550, <2 x double>* %552
%553 = bitcast double* %547 to <2 x double>*
store <2 x double> %551, <2 x double>* %553
%554 = add nuw i64 %531, 4
%555 = icmp eq i64 %554, %497
br i1 %555, label %556, label %530
556: ; preds = %530
br i1 %499, label %600, label %557
557: ; preds = %526, %522, %500, %556
%558 = phi i64 [ %76, %526 ], [ %76, %522 ], [ %76, %500 ], [ %498, %556 ]
%559 = sub i64 %38, %558
%560 = xor i64 %558, -1
%561 = and i64 %559, 1
%562 = icmp eq i64 %561, 0
br i1 %562, label %574, label %563
563: ; preds = %557
%564 = trunc i64 %558 to i32
%565 = add i32 %521, %564
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %19, i64 %566
%568 = load double, double* %567
%569 = add nsw i64 %558, %517
%570 = getelementptr inbounds double, double* %3, i64 %569
%571 = load double, double* %570
%572 = fsub double %571, %568
store double %572, double* %570
%573 = add nuw nsw i64 %558, 1
br label %574
574: ; preds = %563, %557
%575 = phi i64 [ %558, %557 ], [ %573, %563 ]
%576 = icmp eq i64 %560, %67
br i1 %576, label %600, label %577
577: ; preds = %574, %577
%578 = phi i64 [ %598, %577 ], [ %575, %574 ]
%579 = trunc i64 %578 to i32
%580 = add i32 %521, %579
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %19, i64 %581
%583 = load double, double* %582
%584 = add nsw i64 %578, %517
%585 = getelementptr inbounds double, double* %3, i64 %584
%586 = load double, double* %585
%587 = fsub double %586, %583
store double %587, double* %585
%588 = add nuw nsw i64 %578, 1
%589 = trunc i64 %588 to i32
%590 = add i32 %521, %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %19, i64 %591
%593 = load double, double* %592
%594 = add nsw i64 %588, %517
%595 = getelementptr inbounds double, double* %3, i64 %594
%596 = load double, double* %595
%597 = fsub double %596, %593
store double %597, double* %595
%598 = add nuw nsw i64 %578, 2
%599 = icmp eq i64 %598, %36
br i1 %599, label %600, label %577
600: ; preds = %574, %577, %556
%601 = add nuw nsw i64 %503, 1
%602 = icmp eq i64 %601, %36
%603 = add i32 %502, 1
%604 = add i64 %501, 1
br i1 %602, label %609, label %500
605: ; preds = %333
%606 = tail call i32 @mmult(double* %19, double* %16, double* %21, i32 %214, i32 %214, i32 1)
%607 = tail call i32 @scale(double* %21, i32 %214, i32 1, double %213)
%608 = tail call i32 @mmult(double* %21, double* %16, double* %19, i32 %214, i32 1, i32 %214)
br label %609
609: ; preds = %600, %605, %488
%610 = icmp slt i64 %76, %29
br i1 %610, label %611, label %1119
611: ; preds = %609
%612 = icmp ult i64 %331, %27
br i1 %612, label %613, label %728
613: ; preds = %611
%614 = mul nsw i64 %76, %27
%615 = xor i64 %76, -1
%616 = icmp ult i64 %120, 4
br i1 %616, label %680, label %617
617: ; preds = %613
%618 = icmp ult i8* %14, %130
%619 = icmp ult i8* %126, %124
%620 = and i1 %618, %619
br i1 %620, label %680, label %621
621: ; preds = %617
%622 = and i64 %120, -4
%623 = add i64 %74, %622
%624 = and i64 %93, 1
%625 = icmp ult i64 %91, 4
br i1 %625, label %661, label %626
626: ; preds = %621
%627 = and i64 %93, 9223372036854775806
br label %628
628: ; preds = %628, %626
%629 = phi i64 [ 0, %626 ], [ %658, %628 ]
%630 = phi i64 [ 0, %626 ], [ %659, %628 ]
%631 = add i64 %74, %629
%632 = add nuw nsw i64 %631, %614
%633 = getelementptr inbounds double, double* %0, i64 %632
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %633, i64 2
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = add nsw i64 %631, %615
%640 = getelementptr inbounds double, double* %13, i64 %639
%641 = bitcast double* %640 to <2 x double>*
store <2 x double> %635, <2 x double>* %641
%642 = getelementptr inbounds double, double* %640, i64 2
%643 = bitcast double* %642 to <2 x double>*
store <2 x double> %638, <2 x double>* %643
%644 = or i64 %629, 4
%645 = add i64 %74, %644
%646 = add nuw nsw i64 %645, %614
%647 = getelementptr inbounds double, double* %0, i64 %646
%648 = bitcast double* %647 to <2 x double>*
%649 = load <2 x double>, <2 x double>* %648
%650 = getelementptr inbounds double, double* %647, i64 2
%651 = bitcast double* %650 to <2 x double>*
%652 = load <2 x double>, <2 x double>* %651
%653 = add nsw i64 %645, %615
%654 = getelementptr inbounds double, double* %13, i64 %653
%655 = bitcast double* %654 to <2 x double>*
store <2 x double> %649, <2 x double>* %655
%656 = getelementptr inbounds double, double* %654, i64 2
%657 = bitcast double* %656 to <2 x double>*
store <2 x double> %652, <2 x double>* %657
%658 = add nuw i64 %629, 8
%659 = add i64 %630, 2
%660 = icmp eq i64 %659, %627
br i1 %660, label %661, label %628
661: ; preds = %628, %621
%662 = phi i64 [ 0, %621 ], [ %658, %628 ]
%663 = icmp eq i64 %624, 0
br i1 %663, label %678, label %664
664: ; preds = %661
%665 = add i64 %74, %662
%666 = add nuw nsw i64 %665, %614
%667 = getelementptr inbounds double, double* %0, i64 %666
%668 = bitcast double* %667 to <2 x double>*
%669 = load <2 x double>, <2 x double>* %668
%670 = getelementptr inbounds double, double* %667, i64 2
%671 = bitcast double* %670 to <2 x double>*
%672 = load <2 x double>, <2 x double>* %671
%673 = add nsw i64 %665, %615
%674 = getelementptr inbounds double, double* %13, i64 %673
%675 = bitcast double* %674 to <2 x double>*
store <2 x double> %669, <2 x double>* %675
%676 = getelementptr inbounds double, double* %674, i64 2
%677 = bitcast double* %676 to <2 x double>*
store <2 x double> %672, <2 x double>* %677
br label %678
678: ; preds = %661, %664
%679 = icmp eq i64 %120, %622
br i1 %679, label %728, label %680
680: ; preds = %617, %613, %678
%681 = phi i64 [ %74, %617 ], [ %74, %613 ], [ %623, %678 ]
%682 = sub i64 %30, %681
%683 = xor i64 %681, -1
%684 = add i64 %683, %30
%685 = and i64 %682, 3
%686 = icmp eq i64 %685, 0
br i1 %686, label %698, label %687
687: ; preds = %680, %687
%688 = phi i64 [ %695, %687 ], [ %681, %680 ]
%689 = phi i64 [ %696, %687 ], [ 0, %680 ]
%690 = add nuw nsw i64 %688, %614
%691 = getelementptr inbounds double, double* %0, i64 %690
%692 = load double, double* %691
%693 = add nsw i64 %688, %615
%694 = getelementptr inbounds double, double* %13, i64 %693
store double %692, double* %694
%695 = add nuw nsw i64 %688, 1
%696 = add i64 %689, 1
%697 = icmp eq i64 %696, %685
br i1 %697, label %698, label %687
698: ; preds = %687, %680
%699 = phi i64 [ %681, %680 ], [ %695, %687 ]
%700 = icmp ult i64 %684, 3
br i1 %700, label %728, label %701
701: ; preds = %698, %701
%702 = phi i64 [ %726, %701 ], [ %699, %698 ]
%703 = add nuw nsw i64 %702, %614
%704 = getelementptr inbounds double, double* %0, i64 %703
%705 = load double, double* %704
%706 = add nsw i64 %702, %615
%707 = getelementptr inbounds double, double* %13, i64 %706
store double %705, double* %707
%708 = add nuw nsw i64 %702, 1
%709 = add nuw nsw i64 %708, %614
%710 = getelementptr inbounds double, double* %0, i64 %709
%711 = load double, double* %710
%712 = sub i64 %702, %76
%713 = getelementptr inbounds double, double* %13, i64 %712
store double %711, double* %713
%714 = add nuw nsw i64 %702, 2
%715 = add nuw nsw i64 %714, %614
%716 = getelementptr inbounds double, double* %0, i64 %715
%717 = load double, double* %716
%718 = add nsw i64 %714, %615
%719 = getelementptr inbounds double, double* %13, i64 %718
store double %717, double* %719
%720 = add nuw nsw i64 %702, 3
%721 = add nuw nsw i64 %720, %614
%722 = getelementptr inbounds double, double* %0, i64 %721
%723 = load double, double* %722
%724 = add nsw i64 %720, %615
%725 = getelementptr inbounds double, double* %13, i64 %724
store double %723, double* %725
%726 = add nuw nsw i64 %702, 4
%727 = icmp eq i64 %726, %30
br i1 %727, label %728, label %701
728: ; preds = %698, %701, %678, %611
%729 = add nsw i64 %215, -1
%730 = add nsw i32 %216, -1
%731 = trunc i64 %729 to i32
%732 = tail call double @house(double* %13, i32 %731, double* %16)
br i1 %173, label %733, label %992
733: ; preds = %728
%734 = xor i64 %76, -1
%735 = icmp ult i64 %132, 4
%736 = trunc i64 %140 to i32
%737 = icmp ugt i64 %140, 4294967295
%738 = and i64 %132, -4
%739 = add i64 %74, %738
%740 = and i64 %89, 1
%741 = icmp ult i64 %87, 4
%742 = and i64 %89, 9223372036854775806
%743 = icmp eq i64 %740, 0
%744 = icmp eq i64 %132, %738
br label %745
745: ; preds = %733, %870
%746 = phi i64 [ 0, %733 ], [ %874, %870 ]
%747 = phi i32 [ 0, %733 ], [ %873, %870 ]
%748 = phi i64 [ %76, %733 ], [ %871, %870 ]
%749 = mul i64 %746, %30
%750 = add i64 %749, 1
%751 = getelementptr double, double* %0, i64 %750
%752 = bitcast double* %751 to i8*
%753 = getelementptr i8, i8* %752, i64 %133
%754 = add i64 %135, %749
%755 = getelementptr double, double* %0, i64 %754
%756 = mul i64 %136, %746
%757 = shl i64 %756, 32
%758 = ashr exact i64 %757, 32
%759 = getelementptr double, double* %19, i64 %758
%760 = getelementptr double, double* %139, i64 %758
%761 = bitcast double* %760 to i8*
%762 = mul i32 %142, %747
%763 = mul nsw i64 %748, %27
br i1 %612, label %764, label %870
764: ; preds = %745
%765 = sub nuw nsw i64 %748, %76
%766 = mul nsw i64 %765, %729
%767 = add i64 %766, %734
br i1 %735, label %833, label %768
768: ; preds = %764
%769 = add i32 %762, %736
%770 = icmp slt i32 %769, %762
%771 = or i1 %770, %737
br i1 %771, label %833, label %772
772: ; preds = %768
%773 = icmp ult i8* %753, %761
%774 = icmp ult double* %759, %755
%775 = and i1 %773, %774
br i1 %775, label %833, label %776
776: ; preds = %772
br i1 %741, label %814, label %777
777: ; preds = %776, %777
%778 = phi i64 [ %811, %777 ], [ 0, %776 ]
%779 = phi i64 [ %812, %777 ], [ 0, %776 ]
%780 = add i64 %74, %778
%781 = add nuw nsw i64 %780, %763
%782 = getelementptr inbounds double, double* %0, i64 %781
%783 = bitcast double* %782 to <2 x double>*
%784 = load <2 x double>, <2 x double>* %783
%785 = getelementptr inbounds double, double* %782, i64 2
%786 = bitcast double* %785 to <2 x double>*
%787 = load <2 x double>, <2 x double>* %786
%788 = add i64 %767, %780
%789 = shl i64 %788, 32
%790 = ashr exact i64 %789, 32
%791 = getelementptr inbounds double, double* %19, i64 %790
%792 = bitcast double* %791 to <2 x double>*
store <2 x double> %784, <2 x double>* %792
%793 = getelementptr inbounds double, double* %791, i64 2
%794 = bitcast double* %793 to <2 x double>*
store <2 x double> %787, <2 x double>* %794
%795 = or i64 %778, 4
%796 = add i64 %74, %795
%797 = add nuw nsw i64 %796, %763
%798 = getelementptr inbounds double, double* %0, i64 %797
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = getelementptr inbounds double, double* %798, i64 2
%802 = bitcast double* %801 to <2 x double>*
%803 = load <2 x double>, <2 x double>* %802
%804 = add i64 %767, %796
%805 = shl i64 %804, 32
%806 = ashr exact i64 %805, 32
%807 = getelementptr inbounds double, double* %19, i64 %806
%808 = bitcast double* %807 to <2 x double>*
store <2 x double> %800, <2 x double>* %808
%809 = getelementptr inbounds double, double* %807, i64 2
%810 = bitcast double* %809 to <2 x double>*
store <2 x double> %803, <2 x double>* %810
%811 = add nuw i64 %778, 8
%812 = add i64 %779, 2
%813 = icmp eq i64 %812, %742
br i1 %813, label %814, label %777
814: ; preds = %777, %776
%815 = phi i64 [ 0, %776 ], [ %811, %777 ]
br i1 %743, label %832, label %816
816: ; preds = %814
%817 = add i64 %74, %815
%818 = add nuw nsw i64 %817, %763
%819 = getelementptr inbounds double, double* %0, i64 %818
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = getelementptr inbounds double, double* %819, i64 2
%823 = bitcast double* %822 to <2 x double>*
%824 = load <2 x double>, <2 x double>* %823
%825 = add i64 %767, %817
%826 = shl i64 %825, 32
%827 = ashr exact i64 %826, 32
%828 = getelementptr inbounds double, double* %19, i64 %827
%829 = bitcast double* %828 to <2 x double>*
store <2 x double> %821, <2 x double>* %829
%830 = getelementptr inbounds double, double* %828, i64 2
%831 = bitcast double* %830 to <2 x double>*
store <2 x double> %824, <2 x double>* %831
br label %832
832: ; preds = %814, %816
br i1 %744, label %870, label %833
833: ; preds = %772, %768, %764, %832
%834 = phi i64 [ %74, %772 ], [ %74, %768 ], [ %74, %764 ], [ %739, %832 ]
%835 = sub i64 %30, %834
%836 = xor i64 %834, -1
%837 = and i64 %835, 1
%838 = icmp eq i64 %837, 0
br i1 %838, label %848, label %839
839: ; preds = %833
%840 = add nuw nsw i64 %834, %763
%841 = getelementptr inbounds double, double* %0, i64 %840
%842 = load double, double* %841
%843 = add i64 %767, %834
%844 = shl i64 %843, 32
%845 = ashr exact i64 %844, 32
%846 = getelementptr inbounds double, double* %19, i64 %845
store double %842, double* %846
%847 = add nuw nsw i64 %834, 1
br label %848
848: ; preds = %839, %833
%849 = phi i64 [ %834, %833 ], [ %847, %839 ]
%850 = icmp eq i64 %836, %68
br i1 %850, label %870, label %851
851: ; preds = %848, %851
%852 = phi i64 [ %868, %851 ], [ %849, %848 ]
%853 = add nuw nsw i64 %852, %763
%854 = getelementptr inbounds double, double* %0, i64 %853
%855 = load double, double* %854
%856 = add i64 %767, %852
%857 = shl i64 %856, 32
%858 = ashr exact i64 %857, 32
%859 = getelementptr inbounds double, double* %19, i64 %858
store double %855, double* %859
%860 = add nuw nsw i64 %852, 1
%861 = add nuw nsw i64 %860, %763
%862 = getelementptr inbounds double, double* %0, i64 %861
%863 = load double, double* %862
%864 = add i64 %767, %860
%865 = shl i64 %864, 32
%866 = ashr exact i64 %865, 32
%867 = getelementptr inbounds double, double* %19, i64 %866
store double %863, double* %867
%868 = add nuw nsw i64 %852, 2
%869 = icmp eq i64 %868, %30
br i1 %869, label %870, label %851
870: ; preds = %848, %851, %832, %745
%871 = add nuw nsw i64 %748, 1
%872 = icmp eq i64 %871, %37
%873 = add i32 %747, 1
%874 = add i64 %746, 1
br i1 %872, label %875, label %745
875: ; preds = %870
%876 = tail call i32 @mmult(double* %19, double* %16, double* %21, i32 %214, i32 %730, i32 1)
%877 = tail call i32 @scale(double* %21, i32 %214, i32 1, double %732)
%878 = tail call i32 @mmult(double* %21, double* %16, double* %19, i32 %214, i32 1, i32 %730)
br i1 %173, label %879, label %996
879: ; preds = %875
%880 = xor i64 %76, -1
%881 = icmp ult i64 %144, 4
%882 = trunc i64 %152 to i32
%883 = icmp ugt i64 %152, 4294967295
%884 = and i64 %144, -4
%885 = add i64 %74, %884
%886 = icmp eq i64 %144, %884
br label %887
887: ; preds = %879, %987
%888 = phi i64 [ 0, %879 ], [ %991, %987 ]
%889 = phi i32 [ 0, %879 ], [ %990, %987 ]
%890 = phi i64 [ %76, %879 ], [ %988, %987 ]
%891 = mul i64 %888, %30
%892 = add i64 %891, 1
%893 = getelementptr double, double* %0, i64 %892
%894 = bitcast double* %893 to i8*
%895 = getelementptr i8, i8* %894, i64 %145
%896 = add i64 %147, %891
%897 = getelementptr double, double* %0, i64 %896
%898 = mul i64 %148, %888
%899 = shl i64 %898, 32
%900 = ashr exact i64 %899, 32
%901 = getelementptr double, double* %19, i64 %900
%902 = getelementptr double, double* %151, i64 %900
%903 = bitcast double* %902 to i8*
%904 = mul i32 %154, %889
%905 = mul nsw i64 %890, %27
br i1 %612, label %906, label %987
906: ; preds = %887
%907 = sub nuw nsw i64 %890, %76
%908 = mul nsw i64 %907, %729
%909 = add i64 %908, %880
br i1 %881, label %944, label %910
910: ; preds = %906
%911 = add i32 %904, %882
%912 = icmp slt i32 %911, %904
%913 = or i1 %912, %883
br i1 %913, label %944, label %914
914: ; preds = %910
%915 = icmp ult i8* %895, %903
%916 = icmp ult double* %901, %897
%917 = and i1 %915, %916
br i1 %917, label %944, label %918
918: ; preds = %914, %918
%919 = phi i64 [ %941, %918 ], [ 0, %914 ]
%920 = add i64 %74, %919
%921 = add i64 %909, %920
%922 = shl i64 %921, 32
%923 = ashr exact i64 %922, 32
%924 = getelementptr inbounds double, double* %19, i64 %923
%925 = bitcast double* %924 to <2 x double>*
%926 = load <2 x double>, <2 x double>* %925
%927 = getelementptr inbounds double, double* %924, i64 2
%928 = bitcast double* %927 to <2 x double>*
%929 = load <2 x double>, <2 x double>* %928
%930 = add nuw nsw i64 %920, %905
%931 = getelementptr inbounds double, double* %0, i64 %930
%932 = bitcast double* %931 to <2 x double>*
%933 = load <2 x double>, <2 x double>* %932
%934 = getelementptr inbounds double, double* %931, i64 2
%935 = bitcast double* %934 to <2 x double>*
%936 = load <2 x double>, <2 x double>* %935
%937 = fsub <2 x double> %933, %926
%938 = fsub <2 x double> %936, %929
%939 = bitcast double* %931 to <2 x double>*
store <2 x double> %937, <2 x double>* %939
%940 = bitcast double* %934 to <2 x double>*
store <2 x double> %938, <2 x double>* %940
%941 = add nuw i64 %919, 4
%942 = icmp eq i64 %941, %884
br i1 %942, label %943, label %918
943: ; preds = %918
br i1 %886, label %987, label %944
944: ; preds = %914, %910, %906, %943
%945 = phi i64 [ %74, %914 ], [ %74, %910 ], [ %74, %906 ], [ %885, %943 ]
%946 = sub i64 %30, %945
%947 = xor i64 %945, -1
%948 = and i64 %946, 1
%949 = icmp eq i64 %948, 0
br i1 %949, label %961, label %950
950: ; preds = %944
%951 = add i64 %909, %945
%952 = shl i64 %951, 32
%953 = ashr exact i64 %952, 32
%954 = getelementptr inbounds double, double* %19, i64 %953
%955 = load double, double* %954
%956 = add nuw nsw i64 %945, %905
%957 = getelementptr inbounds double, double* %0, i64 %956
%958 = load double, double* %957
%959 = fsub double %958, %955
store double %959, double* %957
%960 = add nuw nsw i64 %945, 1
br label %961
961: ; preds = %950, %944
%962 = phi i64 [ %945, %944 ], [ %960, %950 ]
%963 = icmp eq i64 %947, %69
br i1 %963, label %987, label %964
964: ; preds = %961, %964
%965 = phi i64 [ %985, %964 ], [ %962, %961 ]
%966 = add i64 %909, %965
%967 = shl i64 %966, 32
%968 = ashr exact i64 %967, 32
%969 = getelementptr inbounds double, double* %19, i64 %968
%970 = load double, double* %969
%971 = add nuw nsw i64 %965, %905
%972 = getelementptr inbounds double, double* %0, i64 %971
%973 = load double, double* %972
%974 = fsub double %973, %970
store double %974, double* %972
%975 = add nuw nsw i64 %965, 1
%976 = add i64 %909, %975
%977 = shl i64 %976, 32
%978 = ashr exact i64 %977, 32
%979 = getelementptr inbounds double, double* %19, i64 %978
%980 = load double, double* %979
%981 = add nuw nsw i64 %975, %905
%982 = getelementptr inbounds double, double* %0, i64 %981
%983 = load double, double* %982
%984 = fsub double %983, %980
store double %984, double* %982
%985 = add nuw nsw i64 %965, 2
%986 = icmp eq i64 %985, %30
br i1 %986, label %987, label %964
987: ; preds = %961, %964, %943, %887
%988 = add nuw nsw i64 %890, 1
%989 = icmp eq i64 %988, %38
%990 = add i32 %889, 1
%991 = add i64 %888, 1
br i1 %989, label %996, label %887
992: ; preds = %728
%993 = tail call i32 @mmult(double* %19, double* %16, double* %21, i32 %214, i32 %730, i32 1)
%994 = tail call i32 @scale(double* %21, i32 %214, i32 1, double %732)
%995 = tail call i32 @mmult(double* %21, double* %16, double* %19, i32 %214, i32 1, i32 %730)
br label %996
996: ; preds = %987, %992, %875
%997 = mul nsw i64 %76, %27
%998 = add nuw nsw i64 %76, 2
%999 = icmp ult i64 %998, %27
br i1 %999, label %1000, label %1119
1000: ; preds = %996
%1001 = zext i32 %169 to i64
%1002 = icmp ult i64 %158, 4
br i1 %1002, label %1067, label %1003
1003: ; preds = %1000
%1004 = icmp ult double* %162, %168
%1005 = icmp ult double* %41, %167
%1006 = and i1 %1004, %1005
br i1 %1006, label %1067, label %1007
1007: ; preds = %1003
%1008 = and i64 %158, -4
%1009 = or i64 %1008, 1
%1010 = add nsw i64 %1008, %171
%1011 = and i64 %85, 1
%1012 = icmp ult i64 %83, 4
br i1 %1012, label %1048, label %1013
1013: ; preds = %1007
%1014 = and i64 %85, 9223372036854775806
br label %1015
1015: ; preds = %1015, %1013
%1016 = phi i64 [ 0, %1013 ], [ %1045, %1015 ]
%1017 = phi i64 [ 0, %1013 ], [ %1046, %1015 ]
%1018 = or i64 %1016, 1
%1019 = add i64 %1016, %171
%1020 = getelementptr inbounds double, double* %16, i64 %1018
%1021 = bitcast double* %1020 to <2 x double>*
%1022 = load <2 x double>, <2 x double>* %1021
%1023 = getelementptr inbounds double, double* %1020, i64 2
%1024 = bitcast double* %1023 to <2 x double>*
%1025 = load <2 x double>, <2 x double>* %1024
%1026 = add nsw i64 %1019, %997
%1027 = getelementptr inbounds double, double* %0, i64 %1026
%1028 = bitcast double* %1027 to <2 x double>*
store <2 x double> %1022, <2 x double>* %1028
%1029 = getelementptr inbounds double, double* %1027, i64 2
%1030 = bitcast double* %1029 to <2 x double>*
store <2 x double> %1025, <2 x double>* %1030
%1031 = or i64 %1016, 4
%1032 = or i64 %1016, 5
%1033 = add i64 %1031, %171
%1034 = getelementptr inbounds double, double* %16, i64 %1032
%1035 = bitcast double* %1034 to <2 x double>*
%1036 = load <2 x double>, <2 x double>* %1035
%1037 = getelementptr inbounds double, double* %1034, i64 2
%1038 = bitcast double* %1037 to <2 x double>*
%1039 = load <2 x double>, <2 x double>* %1038
%1040 = add nsw i64 %1033, %997
%1041 = getelementptr inbounds double, double* %0, i64 %1040
%1042 = bitcast double* %1041 to <2 x double>*
store <2 x double> %1036, <2 x double>* %1042
%1043 = getelementptr inbounds double, double* %1041, i64 2
%1044 = bitcast double* %1043 to <2 x double>*
store <2 x double> %1039, <2 x double>* %1044
%1045 = add nuw i64 %1016, 8
%1046 = add i64 %1017, 2
%1047 = icmp eq i64 %1046, %1014
br i1 %1047, label %1048, label %1015
1048: ; preds = %1015, %1007
%1049 = phi i64 [ 0, %1007 ], [ %1045, %1015 ]
%1050 = icmp eq i64 %1011, 0
br i1 %1050, label %1065, label %1051
1051: ; preds = %1048
%1052 = or i64 %1049, 1
%1053 = add i64 %1049, %171
%1054 = getelementptr inbounds double, double* %16, i64 %1052
%1055 = bitcast double* %1054 to <2 x double>*
%1056 = load <2 x double>, <2 x double>* %1055
%1057 = getelementptr inbounds double, double* %1054, i64 2
%1058 = bitcast double* %1057 to <2 x double>*
%1059 = load <2 x double>, <2 x double>* %1058
%1060 = add nsw i64 %1053, %997
%1061 = getelementptr inbounds double, double* %0, i64 %1060
%1062 = bitcast double* %1061 to <2 x double>*
store <2 x double> %1056, <2 x double>* %1062
%1063 = getelementptr inbounds double, double* %1061, i64 2
%1064 = bitcast double* %1063 to <2 x double>*
store <2 x double> %1059, <2 x double>* %1064
br label %1065
1065: ; preds = %1048, %1051
%1066 = icmp eq i64 %158, %1008
br i1 %1066, label %1119, label %1067
1067: ; preds = %1003, %1000, %1065
%1068 = phi i64 [ 1, %1003 ], [ 1, %1000 ], [ %1009, %1065 ]
%1069 = phi i64 [ %171, %1003 ], [ %171, %1000 ], [ %1010, %1065 ]
%1070 = sub nsw i64 %79, %1068
%1071 = xor i64 %1068, -1
%1072 = add nsw i64 %1071, %79
%1073 = and i64 %1070, 3
%1074 = icmp eq i64 %1073, 0
br i1 %1074, label %1087, label %1075
1075: ; preds = %1067, %1075
%1076 = phi i64 [ %1083, %1075 ], [ %1068, %1067 ]
%1077 = phi i64 [ %1084, %1075 ], [ %1069, %1067 ]
%1078 = phi i64 [ %1085, %1075 ], [ 0, %1067 ]
%1079 = getelementptr inbounds double, double* %16, i64 %1076
%1080 = load double, double* %1079
%1081 = add nsw i64 %1077, %997
%1082 = getelementptr inbounds double, double* %0, i64 %1081
store double %1080, double* %1082
%1083 = add nuw nsw i64 %1076, 1
%1084 = add nsw i64 %1077, 1
%1085 = add i64 %1078, 1
%1086 = icmp eq i64 %1085, %1073
br i1 %1086, label %1087, label %1075
1087: ; preds = %1075, %1067
%1088 = phi i64 [ %1068, %1067 ], [ %1083, %1075 ]
%1089 = phi i64 [ %1069, %1067 ], [ %1084, %1075 ]
%1090 = icmp ult i64 %1072, 3
br i1 %1090, label %1119, label %1091
1091: ; preds = %1087, %1091
%1092 = phi i64 [ %1116, %1091 ], [ %1088, %1087 ]
%1093 = phi i64 [ %1117, %1091 ], [ %1089, %1087 ]
%1094 = getelementptr inbounds double, double* %16, i64 %1092
%1095 = load double, double* %1094
%1096 = add nsw i64 %1093, %997
%1097 = getelementptr inbounds double, double* %0, i64 %1096
store double %1095, double* %1097
%1098 = add nuw nsw i64 %1092, 1
%1099 = add nsw i64 %1093, 1
%1100 = getelementptr inbounds double, double* %16, i64 %1098
%1101 = load double, double* %1100
%1102 = add nsw i64 %1099, %997
%1103 = getelementptr inbounds double, double* %0, i64 %1102
store double %1101, double* %1103
%1104 = add nuw nsw i64 %1092, 2
%1105 = add nsw i64 %1093, 2
%1106 = getelementptr inbounds double, double* %16, i64 %1104
%1107 = load double, double* %1106
%1108 = add nsw i64 %1105, %997
%1109 = getelementptr inbounds double, double* %0, i64 %1108
store double %1107, double* %1109
%1110 = add nuw nsw i64 %1092, 3
%1111 = add nsw i64 %1093, 3
%1112 = getelementptr inbounds double, double* %16, i64 %1110
%1113 = load double, double* %1112
%1114 = add nsw i64 %1111, %997
%1115 = getelementptr inbounds double, double* %0, i64 %1114
store double %1113, double* %1115
%1116 = add nuw nsw i64 %1092, 4
%1117 = add nsw i64 %1093, 4
%1118 = icmp eq i64 %1116, %1001
br i1 %1118, label %1119, label %1091
1119: ; preds = %1087, %1091, %1065, %996, %609
%1120 = add nsw i64 %71, -1
%1121 = add i32 %75, -1
%1122 = add nuw nsw i64 %74, 1
%1123 = add nuw i32 %73, 1
%1124 = icmp eq i64 %331, %30
br i1 %1124, label %1125, label %70
1125: ; preds = %1119, %10
%1126 = tail call i32 @free(double* %13)
%1127 = tail call i32 @free(double* %16)
%1128 = tail call i32 @free(double* %19)
ret void
}