#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 */
double fabs(double);
int supportSet(double *, double *, double *, double *, int *, double, int);
int generateSolution(double *x, double *z, double *gap, double *v, double *Av,
                     double *g, double *s, int *S, double lambda, int nn) {
  int i, m, numS, n = nn + 1;
  double temp, funVal1, funVal2;
  temp = 0;
  m = nn % 5;
  if (m != 0) {
    for (i = 0; i < m; i++)
      temp += z[i] * (g[i] + Av[i]);
  }
  for (i = m; i < nn; i += 5)
    temp = temp + z[i] * (g[i] + Av[i]) + z[i + 1] * (g[i + 1] + Av[i + 1]) +
           z[i + 2] * (g[i + 2] + Av[i + 2]) +
           z[i + 3] * (g[i + 3] + Av[i + 3]) +
           z[i + 4] * (g[i + 4] + Av[i + 4]);
  funVal1 = temp / 2;
  temp = 0;
  m = nn % 5;
  if (m != 0) {
    for (i = 0; i < m; i++)
      temp += fabs(g[i]);
  }
  for (i = m; i < nn; i += 5)
    temp = temp + fabs(g[i]) + fabs(g[i + 1]) + fabs(g[i + 2]) +
           fabs(g[i + 3]) + fabs(g[i + 4]);
  funVal1 = funVal1 + temp * lambda;
  numS = supportSet(x, v, z, g, S, lambda, nn);
  temp = 0;
  m = n % 5;
  if (m != 0) {
    for (i = 0; i < m; i++)
      temp += (x[i] - v[i]) * (x[i] - v[i]);
  }
  for (i = m; i < n; i += 5)
    temp = temp + (x[i] - v[i]) * (x[i] - v[i]) +
           (x[i + 1] - v[i + 1]) * (x[i + 1] - v[i + 1]) +
           (x[i + 2] - v[i + 2]) * (x[i + 2] - v[i + 2]) +
           (x[i + 3] - v[i + 3]) * (x[i + 3] - v[i + 3]) +
           (x[i + 4] - v[i + 4]) * (x[i + 4] - v[i + 4]);
  funVal2 = temp / 2;
  temp = 0;
  m = nn % 5;
  if (m != 0) {
    for (i = 0; i < m; i++)
      temp += fabs(x[i + 1] - x[i]);
  }
  for (i = m; i < nn; i += 5)
    temp = temp + fabs(x[i + 1] - x[i]) + fabs(x[i + 2] - x[i + 1]) +
           fabs(x[i + 3] - x[i + 2]) + fabs(x[i + 4] - x[i + 3]) +
           fabs(x[i + 5] - x[i + 4]);
  funVal2 = funVal2 + lambda * temp;
  if (funVal2 > funVal1) {
    x[0] = v[0] + z[0];
    for (i = 1; i < n - 1; i++)
      x[i] = v[i] - z[i - 1] + z[i];
    x[n - 1] = v[n - 1] - z[n - 2];
  } else {
    *gap = *gap - (funVal1 - funVal2);
    if (*gap < 0)
      *gap = 0;
  }
  return (numS);
}


x86 assembly (clang, -O0):
<generateSolution>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x20(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     11c8 <generateSolution+0xb8>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    11c3 <generateSolution+0xb3>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1170 <generateSolution+0x60>
jmp    11c8 <generateSolution+0xb8>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1319 <generateSolution+0x209>
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ce <generateSolution+0xbe>
movsd  -0x50(%rbp),%xmm0
movsd  0xcda(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x20(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     1397 <generateSolution+0x287>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1392 <generateSolution+0x282>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc9a(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1356 <generateSolution+0x246>
jmp    1397 <generateSolution+0x287>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1461 <generateSolution+0x351>
movsd  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc4e(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc2d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc0c(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbeb(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbca(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x3c(%rbp)
jmp    139d <generateSolution+0x28d>
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x18(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%r9d
call   1030 <supportSet@plt>
mov    %eax,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     152e <generateSolution+0x41e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1529 <generateSolution+0x419>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14c9 <generateSolution+0x3b9>
jmp    152e <generateSolution+0x41e>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    16d4 <generateSolution+0x5c4>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x3c(%rbp)
jmp    1534 <generateSolution+0x424>
movsd  -0x50(%rbp),%xmm0
movsd  0x91f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x20(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     1764 <generateSolution+0x654>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    175f <generateSolution+0x64f>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x8cd(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1711 <generateSolution+0x601>
jmp    1764 <generateSolution+0x654>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1888 <generateSolution+0x778>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x86f(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x83c(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x809(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x7d6(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movaps 0x7a3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x3c(%rbp)
jmp    176a <generateSolution+0x65a>
movsd  -0x60(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1966 <generateSolution+0x856>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    192b <generateSolution+0x81b>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18d3 <generateSolution+0x7c3>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19a5 <generateSolution+0x895>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x58(%rbp),%xmm1
subsd  -0x60(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    19a0 <generateSolution+0x890>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    19a5 <generateSolution+0x895>
mov    -0x44(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generateSolution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movapd %xmm0,%xmm5
mov    %r9,%rbp
mov    %rcx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
movslq 0x80(%rsp),%r9
imul   $0x66666667,%r9,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x21,%rax
add    %ecx,%eax
lea    (%rax,%rax,4),%eax
mov    %r9d,%r12d
sub    %eax,%r12d
test   %r12d,%r12d
mov    %rdx,0x30(%rsp)
jle    1214 <generateSolution+0x104>
movsd  0x0(%rbp),%xmm0
addsd  (%r8),%xmm0
mulsd  (%r14),%xmm0
xorpd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
cmp    $0x1,%r12d
je     1218 <generateSolution+0x108>
movsd  0x8(%rbp),%xmm0
addsd  0x8(%r8),%xmm0
mulsd  0x8(%r14),%xmm0
addsd  %xmm0,%xmm4
cmp    $0x2,%r12d
je     1218 <generateSolution+0x108>
movsd  0x10(%rbp),%xmm0
addsd  0x10(%r8),%xmm0
mulsd  0x10(%r14),%xmm0
addsd  %xmm0,%xmm4
cmp    $0x3,%r12d
je     1218 <generateSolution+0x108>
movsd  0x18(%rbp),%xmm0
addsd  0x18(%r8),%xmm0
mulsd  0x18(%r14),%xmm0
addsd  %xmm0,%xmm4
cmp    $0x4,%r12d
je     1218 <generateSolution+0x108>
movsd  0x20(%rbp),%xmm0
movsd  0x28(%rbp),%xmm1
addsd  0x20(%r8),%xmm0
mulsd  0x20(%r14),%xmm0
addsd  0x28(%r8),%xmm1
mulsd  0x28(%r14),%xmm1
addsd  %xmm4,%xmm0
movsd  0x30(%rbp),%xmm4
addsd  0x30(%r8),%xmm4
addsd  %xmm0,%xmm1
mulsd  0x30(%r14),%xmm4
addsd  %xmm1,%xmm4
jmp    1218 <generateSolution+0x108>
xorpd  %xmm4,%xmm4
movslq %r9d,%r13
cmp    %r9d,%r12d
jge    12af <generateSolution+0x19f>
movslq %r12d,%rax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
addsd  (%r8,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
addsd  0x8(%r8,%rax,8),%xmm1
addsd  %xmm4,%xmm0
mulsd  0x8(%r14,%rax,8),%xmm1
movsd  0x10(%rbp,%rax,8),%xmm2
addsd  0x10(%r8,%rax,8),%xmm2
mulsd  0x10(%r14,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rbp,%rax,8),%xmm0
addsd  0x18(%r8,%rax,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x18(%r14,%rax,8),%xmm0
movsd  0x20(%rbp,%rax,8),%xmm4
addsd  0x20(%r8,%rax,8),%xmm4
mulsd  0x20(%r14,%rax,8),%xmm4
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm4
add    $0x5,%rax
cmp    %r13,%rax
jl     1230 <generateSolution+0x120>
test   %r12d,%r12d
jle    1345 <generateSolution+0x235>
movsd  0x0(%rbp),%xmm6
andpd  0xd4b(%rip),%xmm6
cmp    $0x1,%r12d
je     1349 <generateSolution+0x239>
movsd  0x8(%rbp),%xmm0
andpd  0xd38(%rip),%xmm0
addsd  %xmm0,%xmm6
cmp    $0x2,%r12d
je     1349 <generateSolution+0x239>
movsd  0x10(%rbp),%xmm0
andpd  0xd21(%rip),%xmm0
addsd  %xmm0,%xmm6
cmp    $0x3,%r12d
je     1349 <generateSolution+0x239>
movsd  0x18(%rbp),%xmm0
andpd  0xd0a(%rip),%xmm0
addsd  %xmm0,%xmm6
cmp    $0x4,%r12d
je     1349 <generateSolution+0x239>
movapd 0xcf8(%rip),%xmm0
movsd  0x20(%rbp),%xmm1
movsd  0x28(%rbp),%xmm2
movsd  0x30(%rbp),%xmm3
andpd  %xmm0,%xmm1
addsd  %xmm1,%xmm6
andpd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
andpd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm3,%xmm6
jmp    1349 <generateSolution+0x239>
xorpd  %xmm6,%xmm6
mov    0x78(%rsp),%r8
lea    0x1(%r9),%eax
cmp    %r9d,%r12d
movsd  %xmm4,0x8(%rsp)
mov    %eax,0x1c(%rsp)
jge    13bf <generateSolution+0x2af>
movslq %r12d,%rax
movapd 0xca4(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x8(%rbp,%rax,8),%xmm2
movsd  0x10(%rbp,%rax,8),%xmm3
movsd  0x18(%rbp,%rax,8),%xmm4
andpd  %xmm0,%xmm1
addsd  %xmm6,%xmm1
andpd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
andpd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  0x20(%rbp,%rax,8),%xmm6
andpd  %xmm0,%xmm6
addsd  %xmm4,%xmm6
add    $0x5,%rax
cmp    %r13,%rax
jl     1370 <generateSolution+0x260>
movapd %xmm6,0x20(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %rbp,%rcx
movsd  %xmm5,0x10(%rsp)
movapd %xmm5,%xmm0
mov    %r9,%rbp
call   1030 <supportSet@plt>
movslq 0x1c(%rsp),%rcx
imul   $0x66666667,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x21,%rdx
add    %esi,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%ecx
test   %ecx,%ecx
jle    14aa <generateSolution+0x39a>
movsd  (%rbx),%xmm1
subsd  (%r15),%xmm1
mulsd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cmp    $0x1,%ecx
je     14ae <generateSolution+0x39e>
movsd  0x8(%rbx),%xmm1
subsd  0x8(%r15),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x2,%ecx
je     14ae <generateSolution+0x39e>
movsd  0x10(%rbx),%xmm1
subsd  0x10(%r15),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x3,%ecx
je     14ae <generateSolution+0x39e>
movsd  0x18(%rbx),%xmm1
subsd  0x18(%r15),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x4,%ecx
je     14ae <generateSolution+0x39e>
movsd  0x20(%rbx),%xmm1
subsd  0x20(%r15),%xmm1
movsd  0x28(%rbx),%xmm2
mulsd  %xmm1,%xmm1
subsd  0x28(%r15),%xmm2
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x30(%rbx),%xmm0
subsd  0x30(%r15),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
jmp    14ae <generateSolution+0x39e>
xorpd  %xmm0,%xmm0
movsd  0x10(%rsp),%xmm9
mov    %rbp,%rdx
movsd  0x8(%rsp),%xmm6
movapd 0x20(%rsp),%xmm10
cmp    %edx,%ecx
jg     1540 <generateSolution+0x430>
movslq %ecx,%rcx
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
subsd  (%r15,%rcx,8),%xmm1
movsd  0x8(%rbx,%rcx,8),%xmm2
mulsd  %xmm1,%xmm1
subsd  0x8(%r15,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rbx,%rcx,8),%xmm0
subsd  0x10(%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  0x18(%rbx,%rcx,8),%xmm1
subsd  0x18(%r15,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rbx,%rcx,8),%xmm0
subsd  0x20(%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x5,%rcx
cmp    %r13,%rcx
jle    14d0 <generateSolution+0x3c0>
mulsd  0xab8(%rip),%xmm6
mulsd  %xmm9,%xmm10
test   %r12d,%r12d
jle    1617 <generateSolution+0x507>
movsd  0x8(%rbx),%xmm2
movapd %xmm2,%xmm1
subsd  (%rbx),%xmm1
andpd  0xaa5(%rip),%xmm1
cmp    $0x1,%r12d
je     161b <generateSolution+0x50b>
movsd  0x10(%rbx),%xmm3
movapd %xmm3,%xmm4
subsd  %xmm2,%xmm4
andpd  0xa86(%rip),%xmm4
addsd  %xmm4,%xmm1
cmp    $0x2,%r12d
je     161b <generateSolution+0x50b>
movsd  0x18(%rbx),%xmm4
movapd %xmm4,%xmm2
subsd  %xmm3,%xmm2
andpd  0xa63(%rip),%xmm2
addsd  %xmm2,%xmm1
cmp    $0x3,%r12d
je     161b <generateSolution+0x50b>
movsd  0x20(%rbx),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm4,%xmm3
andpd  0xa44(%rip),%xmm3
addsd  %xmm3,%xmm1
cmp    $0x4,%r12d
je     161b <generateSolution+0x50b>
movsd  0x28(%rbx),%xmm3
movsd  0x30(%rbx),%xmm4
movapd %xmm4,%xmm5
subsd  %xmm3,%xmm5
subsd  %xmm2,%xmm3
movapd 0xa1c(%rip),%xmm2
andpd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
andpd  %xmm2,%xmm5
addsd  %xmm1,%xmm5
movsd  0x38(%rbx),%xmm1
subsd  %xmm4,%xmm1
andpd  %xmm2,%xmm1
addsd  %xmm5,%xmm1
jmp    161b <generateSolution+0x50b>
xorpd  %xmm1,%xmm1
addsd  %xmm6,%xmm10
mulsd  0x9d8(%rip),%xmm0
cmp    %edx,%r12d
jge    16c0 <generateSolution+0x5b0>
movslq %r12d,%rcx
movsd  (%rbx,%rcx,8),%xmm3
movapd 0x9ce(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rbx,%rcx,8),%xmm4
movsd  0x10(%rbx,%rcx,8),%xmm5
movsd  0x18(%rbx,%rcx,8),%xmm6
movsd  0x20(%rbx,%rcx,8),%xmm2
movapd %xmm2,%xmm7
subsd  %xmm6,%xmm7
subsd  %xmm5,%xmm6
subsd  %xmm4,%xmm5
subsd  %xmm3,%xmm4
andpd  %xmm8,%xmm4
addsd  %xmm1,%xmm4
andpd  %xmm8,%xmm5
addsd  %xmm4,%xmm5
andpd  %xmm8,%xmm6
addsd  %xmm5,%xmm6
andpd  %xmm8,%xmm7
addsd  %xmm6,%xmm7
movsd  0x28(%rbx,%rcx,8),%xmm3
add    $0x5,%rcx
movapd %xmm3,%xmm1
subsd  %xmm2,%xmm1
andpd  %xmm8,%xmm1
addsd  %xmm7,%xmm1
cmp    %r13,%rcx
jl     1650 <generateSolution+0x540>
mulsd  %xmm1,%xmm9
addsd  %xmm0,%xmm9
ucomisd %xmm10,%xmm9
jbe    1780 <generateSolution+0x670>
movsd  (%r15),%xmm0
addsd  (%r14),%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x2,%edx
jl     1857 <generateSolution+0x747>
mov    %edx,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x4,%r8
jae    17b1 <generateSolution+0x6a1>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
jne    1728 <generateSolution+0x618>
movsd  (%r15,%rdx,8),%xmm0
subsd  -0x8(%r14,%rdx,8),%xmm0
addsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    %rcx,%rsi
je     1857 <generateSolution+0x747>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
subsd  -0x8(%r14,%rdx,8),%xmm0
addsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%r15,%rdx,8),%xmm0
subsd  (%r14,%rdx,8),%xmm0
addsd  0x8(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1740 <generateSolution+0x630>
jmp    1857 <generateSolution+0x747>
mov    0x30(%rsp),%rcx
movsd  (%rcx),%xmm0
subsd  %xmm9,%xmm10
subsd  %xmm10,%xmm0
movsd  %xmm0,(%rcx)
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    186a <generateSolution+0x75a>
movq   $0x0,(%rcx)
jmp    186a <generateSolution+0x75a>
lea    0x8(%rbx),%rsi
lea    (%rbx,%rcx,8),%rdi
lea    0x8(%r15),%r9
lea    (%r15,%rcx,8),%r10
lea    (%r14,%rcx,8),%r11
cmp    %r10,%rsi
setb   %r10b
cmp    %rdi,%r9
setb   %r9b
cmp    %r11,%rsi
setb   %sil
cmp    %r14,%rdi
seta   %dil
test   %r9b,%r10b
jne    1701 <generateSolution+0x5f1>
and    %dil,%sil
jne    1701 <generateSolution+0x5f1>
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rdi),%rdx
xor    %esi,%esi
movupd 0x8(%r15,%rsi,8),%xmm0
movupd 0x18(%r15,%rsi,8),%xmm1
movupd (%r14,%rsi,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x8(%r14,%rsi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r14,%rsi,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x18(%r14,%rsi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x8(%rbx,%rsi,8)
movupd %xmm0,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1800 <generateSolution+0x6f0>
cmp    %rdi,%r8
jne    1701 <generateSolution+0x5f1>
movsd  (%r15,%r13,8),%xmm0
subsd  -0x8(%r14,%r13,8),%xmm0
movsd  %xmm0,(%rbx,%r13,8)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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