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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ gram_schmidt(double *, double *, double *, int);
int /*<<< orphan*/ nearest_integer_shift(double *, double *, int, int, int,
                                         double);
void lll_reduce(double *b, int n, double lc, double uc) {
  int i, j, k, l;
  double tmp, B_tmp, mu_tmp;
  double swap_condition;
  double *mu = (double *)calloc(n * n, sizeof(double));
  double *B = (double *)calloc(n, sizeof(double));
  for (i = 0; i < n * n; i++)
    mu[i] = 0;
  for (i = 0; i < n; i++)
    B[i] = 0;
  gram_schmidt(b, mu, B, n);
  k = 1;
  while (k < n) {
    nearest_integer_shift(mu, b, k, k - 1, n, lc);
    swap_condition =
        (uc - mu[k * n + (k - 1)] * mu[k * n + (k - 1)]) * B[k - 1];
    if (B[k] < swap_condition) {
      mu_tmp = mu[k * n + (k - 1)];
      B_tmp = B[k] + mu_tmp * mu_tmp * B[k - 1];
      mu[k * n + (k - 1)] = mu_tmp * B[k - 1] / B_tmp;
      B[k] = B[k - 1] * B[k] / B_tmp;
      B[k - 1] = B_tmp;
      for (i = 0; i < n; i++) {
        tmp = b[i * n + k];
        b[i * n + k] = b[i * n + (k - 1)];
        b[i * n + (k - 1)] = tmp;
      }
      for (j = 0; j < k - 2; j++) {
        tmp = mu[k * n + j];
        mu[k * n + j] = mu[(k - 1) * n + j];
        mu[(k - 1) * n + j] = tmp;
      }
      for (i = k; i < n; i++) {
        tmp = mu[i * n + (k - 1)] - mu_tmp * mu[i * n + k];
        mu[i * n + (k - 1)] = mu[i * n + k] + mu[k * n + (k - 1)] * tmp;
        mu[i * n + k] = tmp;
      }
      if (k > 1)
        k -= 1;
    } else {
      for (l = k - 3; l >= 0; l--) {
        nearest_integer_shift(mu, b, k, l, n, lc);
      }
      k += 1;
    }
  }
  free(mu);
  free(B);
}


x86 assembly (clang, -O0):
<lll_reduce>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    -0xc(%rbp),%edi
imul   -0xc(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    11b6 <lll_reduce+0x76>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1186 <lll_reduce+0x46>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e7 <lll_reduce+0xa7>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11bd <lll_reduce+0x7d>
mov    -0x8(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0xc(%rbp),%ecx
call   1040 <gram_schmidt@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15fb <lll_reduce+0x4bb>
mov    -0x58(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%r8d
movsd  -0x18(%rbp),%xmm0
call   1060 <nearest_integer_shift@plt>
movsd  -0x20(%rbp),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15b0 <lll_reduce+0x470>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    141c <lll_reduce+0x2dc>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1396 <lll_reduce+0x256>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    14aa <lll_reduce+0x36a>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1423 <lll_reduce+0x2e3>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1598 <lll_reduce+0x458>
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14b0 <lll_reduce+0x370>
cmpl   $0x1,-0x2c(%rbp)
jle    15ab <lll_reduce+0x46b>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15f6 <lll_reduce+0x4b6>
mov    -0x2c(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     15ed <lll_reduce+0x4ad>
mov    -0x58(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%ecx
mov    -0xc(%rbp),%r8d
movsd  -0x18(%rbp),%xmm0
call   1060 <nearest_integer_shift@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    15b9 <lll_reduce+0x479>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1202 <lll_reduce+0xc2>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lll_reduce>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movsd  %xmm1,0x80(%rsp)
movsd  %xmm0,0x8(%rsp)
mov    %esi,%ebx
mov    %rdi,(%rsp)
mov    %esi,%ebp
imul   %esi,%ebp
mov    %ebp,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r15
test   %ebp,%ebp
je     11ad <lll_reduce+0x5d>
mov    %ebp,%edx
shl    $0x3,%rdx
mov    %r12,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
test   %ebx,%ebx
jle    16c1 <lll_reduce+0x571>
mov    %ebx,%eax
mov    %rax,0x10(%rsp)
lea    0x0(,%rax,8),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    (%rsp),%rbp
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %ebx,%ecx
call   1040 <gram_schmidt@plt>
cmp    $0x1,%ebx
movsd  0x8(%rsp),%xmm0
je     16d2 <lll_reduce+0x582>
mov    %rbp,%rsi
mov    0x10(%rsp),%rcx
lea    -0x1(%rcx),%rax
mov    %rax,0x70(%rsp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x20(%rsp)
mov    %ecx,%r11d
and    $0xfffffffc,%r11d
mov    %rcx,%rax
shl    $0x4,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rsp)
mov    %rcx,%rdx
shl    $0x5,%rdx
lea    (%rcx,%rcx,2),%rax
lea    -0x8(,%rax,8),%rax
ff
mov    %rax,0x48(%rsp)
lea    -0x8(%rbp),%rax
mov    %rax,0x68(%rsp)
lea    0x0(,%rcx,8),%r14
lea    0x30(%r12),%rax
mov    %rax,0x28(%rsp)
lea    0x8(%r12),%rax
mov    %rax,0x38(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x40(%rsp)
mov    $0x1,%r13d
mov    %ebx,0x1c(%rsp)
mov    %r15,0x78(%rsp)
mov    %r11,0x60(%rsp)
mov    %rdx,0x50(%rsp)
jmp    12a5 <lll_reduce+0x155>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13d
mov    %r15,%rsi
mov    0x78(%rsp),%r15
cmp    %ebx,%r13d
jge    16d2 <lll_reduce+0x582>
movslq %r13d,%rbp
lea    -0x1(%rbp),%ecx
mov    %r12,%rdi
mov    %ebp,%edx
mov    %ebx,%r8d
call   1070 <nearest_integer_shift@plt>
mov    %r13d,%r8d
imul   %ebx,%r8d
lea    (%r8,%rbp,1),%eax
add    $0xffffffff,%eax
movslq %eax,%r9
movsd  (%r12,%r9,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x80(%rsp),%xmm4
subsd  %xmm1,%xmm4
movsd  -0x8(%r15,%rbp,8),%xmm2
movsd  (%r15,%rbp,8),%xmm3
mulsd  %xmm2,%xmm4
ucomisd %xmm3,%xmm4
jbe    1350 <lll_reduce+0x200>
lea    -0x1(%rbp),%r10
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%r9,8)
movsd  (%r15,%r10,8),%xmm2
mulsd  (%r15,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rbp,8)
mov    %r15,%rsi
movsd  %xmm1,(%r15,%r10,8)
cmpq   $0x3,0x70(%rsp)
jae    13a0 <lll_reduce+0x250>
xor    %edx,%edx
jmp    1423 <lll_reduce+0x2d3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x3,%r13d
mov    (%rsp),%r15
movsd  0x8(%rsp),%xmm0
jl     1290 <lll_reduce+0x140>
lea    -0x3(%r13),%ebp
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r13d,%edx
mov    %ebp,%ecx
mov    %ebx,%r8d
movsd  0x8(%rsp),%xmm0
call   1070 <nearest_integer_shift@plt>
movsd  0x8(%rsp),%xmm0
add    $0xffffffff,%ebp
jb     1370 <lll_reduce+0x220>
jmp    1290 <lll_reduce+0x140>
nopl   0x0(%rax)
lea    0x8(,%r10,8),%rdi
mov    0x58(%rsp),%rax
lea    (%rax,%r10,8),%rbp
add    $0x8,%rbp
mov    0x10(%rsp),%rax
lea    0x1(%rax,%r10,1),%rcx
mov    0x48(%rsp),%rax
lea    (%rax,%r10,8),%rbx
add    $0x8,%rbx
mov    (%rsp),%rax
xor    %edx,%edx
mov    0x60(%rsp),%r11
mov    0x50(%rsp),%r15
nopl   0x0(%rax)
movups -0x8(%rax,%rdi,1),%xmm1
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,-0x8(%rax,%rdi,1)
movups -0x8(%rax,%rcx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,-0x8(%rax,%rcx,8)
movups (%rax,%rbp,1),%xmm1
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,(%rax,%rbp,1)
movupd (%rax,%rbx,1),%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rax,%rbx,1)
add    $0x4,%rdx
add    %r15,%rax
cmp    %rdx,%r11
jne    13e0 <lll_reduce+0x290>
cmpq   $0x0,0x20(%rsp)
mov    0x1c(%rsp),%ebx
je     1466 <lll_reduce+0x316>
imul   0x10(%rsp),%rdx
add    %r10,%rdx
mov    0x68(%rsp),%rax
lea    (%rax,%rdx,8),%rax
add    $0x8,%rax
mov    0x20(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd (%rax),%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rax)
add    %r14,%rax
add    $0xffffffffffffffff,%rcx
jne    1450 <lll_reduce+0x300>
cmp    $0x3,%r13d
mov    %rsi,%r15
jl     1640 <lll_reduce+0x4f0>
lea    -0x2(%r13),%edx
mov    %r10d,%eax
imul   %ebx,%eax
movslq %r8d,%r8
cltq
cmp    $0x4,%edx
jb     14b1 <lll_reduce+0x361>
lea    (%r12,%r8,8),%rcx
lea    (%rax,%rdx,1),%rdi
lea    (%r12,%rdi,8),%rdi
cmp    %rdi,%rcx
jae    153a <lll_reduce+0x3ea>
lea    (%r8,%rdx,1),%rcx
lea    (%r12,%rcx,8),%rcx
lea    (%r12,%rax,8),%rdi
cmp    %rcx,%rdi
jae    153a <lll_reduce+0x3ea>
xor    %ebp,%ebp
mov    %rbp,%rcx
test   $0x1,%dl
je     14e2 <lll_reduce+0x392>
lea    (%r8,%rbp,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
lea    (%rax,%rbp,1),%rdi
movsd  (%r12,%rdi,8),%xmm2
movsd  %xmm2,(%r12,%rcx,8)
movsd  %xmm1,(%r12,%rdi,8)
mov    %rbp,%rcx
or     $0x1,%rcx
not    %rbp
add    %rdx,%rbp
je     1640 <lll_reduce+0x4f0>
mov    0x38(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
lea    (%rsi,%r8,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rcx,8),%xmm1
movsd  -0x8(%rax,%rcx,8),%xmm2
movsd  %xmm2,-0x8(%rdi,%rcx,8)
movsd  %xmm1,-0x8(%rax,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm1
movsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rdi,%rcx,8)
movsd  %xmm1,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1500 <lll_reduce+0x3b0>
jmp    1640 <lll_reduce+0x4f0>
mov    %edx,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rcx,%rcx
mov    %r8,0x30(%rsp)
je     15e8 <lll_reduce+0x498>
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x28(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
lea    (%rdi,%rax,8),%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rsi,%rdi,8),%xmm1
movups -0x20(%rsi,%rdi,8),%xmm2
movups -0x30(%r8,%rdi,8),%xmm3
movups -0x20(%r8,%rdi,8),%xmm4
movups %xmm3,-0x30(%rsi,%rdi,8)
movups %xmm4,-0x20(%rsi,%rdi,8)
movups %xmm1,-0x30(%r8,%rdi,8)
movups %xmm2,-0x20(%r8,%rdi,8)
movupd -0x10(%rsi,%rdi,8),%xmm1
movupd (%rsi,%rdi,8),%xmm2
movupd -0x10(%r8,%rdi,8),%xmm3
movupd (%r8,%rdi,8),%xmm4
movupd %xmm3,-0x10(%rsi,%rdi,8)
movupd %xmm4,(%rsi,%rdi,8)
movupd %xmm1,-0x10(%r8,%rdi,8)
movupd %xmm2,(%r8,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1580 <lll_reduce+0x430>
jmp    15ea <lll_reduce+0x49a>
xor    %edi,%edi
test   $0x1,%r11b
mov    0x30(%rsp),%r8
je     1630 <lll_reduce+0x4e0>
lea    (%rdi,%r8,1),%rcx
movupd (%r12,%rcx,8),%xmm1
movupd 0x10(%r12,%rcx,8),%xmm2
add    %rax,%rdi
movupd (%r12,%rdi,8),%xmm3
movupd 0x10(%r12,%rdi,8),%xmm4
movupd %xmm3,(%r12,%rcx,8)
movupd %xmm4,0x10(%r12,%rcx,8)
movupd %xmm1,(%r12,%rdi,8)
movupd %xmm2,0x10(%r12,%rdi,8)
cmp    %rdx,%rbp
jne    14b3 <lll_reduce+0x363>
nopl   0x0(%rax)
cmp    %ebx,%r13d
jge    16a1 <lll_reduce+0x551>
xorpd  0x9b3(%rip),%xmm0
lea    0x1(%r10),%rdx
mov    0x40(%rsp),%rax
imul   %rdx,%rax
lea    (%r12,%rax,8),%rax
mov    0x10(%rsp),%rcx
sub    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%rax),%xmm2
movsd  (%r12,%r9,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,-0x8(%rax)
movsd  %xmm2,(%rax)
add    %r14,%rax
add    $0xffffffffffffffff,%rcx
jne    1670 <lll_reduce+0x520>
cmp    $0x2,%r13d
cmovl  %r13d,%r10d
mov    %r10d,%r13d
movsd  0x8(%rsp),%xmm0
mov    (%rsp),%rsi
cmp    %ebx,%r13d
jl     12a5 <lll_reduce+0x155>
jmp    16d2 <lll_reduce+0x582>
mov    (%rsp),%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %ebx,%ecx
call   1040 <gram_schmidt@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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