#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 */
typedef int int32_t;

/* Variables and functions */
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, int);
int quadprog_ineq(double *, double *, double *, double *, int /*<<< orphan*/,
                  int, int, double *, double *);
int32_t quadprog(int problemLen, double *H, double *f, int inequalityLen,
                 float *A, float *b, int equalityLen, float *Aeq, float *beq,
                 float *lb, float *ub, float *outAns, float *fv) {
  int i;
  int lowerBoundLen = 0;
  int upperBoundLen = 0;
  if (lb)
    lowerBoundLen = problemLen;
  if (ub)
    upperBoundLen = problemLen;
  if (!H || !f)
    return -2;
  if ((!A || !b) && inequalityLen)
    inequalityLen = 0;
  if ((!Aeq || !beq) && equalityLen)
    equalityLen = 0;
  int constraintLength =
      inequalityLen + (equalityLen << 1) + lowerBoundLen + upperBoundLen;
  double *synthesizedA =
      (double *)malloc(constraintLength * problemLen * sizeof(double));
  double *synthesizedb = (double *)malloc(constraintLength * sizeof(double));
  if (inequalityLen) {
    for (i = 0; i < inequalityLen * problemLen; i++)
      synthesizedA[i] = A[i];
    for (i = 0; i < inequalityLen; i++)
      synthesizedb[i] = b[i];
  }
  if (equalityLen) {
    for (i = 0; i < equalityLen; i++) {
      synthesizedb[inequalityLen + i] = beq[i];
      synthesizedb[inequalityLen + equalityLen + i] = -beq[i];
      for (int j = 0; j < problemLen; j++) {
        synthesizedA[inequalityLen * problemLen + i * problemLen + j] =
            Aeq[i * problemLen + j];
        synthesizedA[inequalityLen * problemLen + equalityLen * problemLen +
                     i * problemLen + j] = -Aeq[i * problemLen + j];
      }
    }
  }
  if (lb) {
    memset(synthesizedA + inequalityLen * problemLen +
               (equalityLen << 1) * problemLen,
           0, lowerBoundLen * lowerBoundLen * sizeof(double));
    for (i = 0; i < lowerBoundLen; i++) {
      synthesizedA[inequalityLen * problemLen +
                   (equalityLen << 1) * problemLen + i * lowerBoundLen + i] =
          -1.0;
      synthesizedb[inequalityLen + (equalityLen << 1) + i] = -lb[i];
    }
  }
  if (ub) {
    memset(synthesizedA + inequalityLen * problemLen +
               (equalityLen << 1) * problemLen + lowerBoundLen * lowerBoundLen,
           0, upperBoundLen * upperBoundLen * sizeof(double));
    for (i = 0; i < upperBoundLen; i++) {
      synthesizedA[inequalityLen * problemLen +
                   (equalityLen << 1) * problemLen +
                   lowerBoundLen * lowerBoundLen + i * upperBoundLen + i] = 1.0;
      synthesizedb[inequalityLen + (equalityLen << 1) + lowerBoundLen + i] =
          ub[i];
    }
  }
  double *ans = (double *)malloc(problemLen * sizeof(double));
  double fval;
  int err = quadprog_ineq(H, f, synthesizedA, synthesizedb, 0, problemLen,
                          constraintLength, ans, &fval);
  for (i = 0; i < problemLen; i++)
    outAns[i] = (float)ans[i];
  free(ans);
  *fv = (float)fval;
  free(synthesizedA);
  free(synthesizedb);
  return err;
}


x86 assembly (clang, -O0):
<quadprog>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpq   $0x0,0x28(%rbp)
je     119b <quadprog+0x5b>
mov    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpq   $0x0,0x30(%rbp)
je     11ac <quadprog+0x6c>
mov    -0x8(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     11c2 <quadprog+0x82>
cmpq   $0x0,-0x18(%rbp)
jne    11ce <quadprog+0x8e>
movl   $0xfffffffe,-0x4(%rbp)
jmp    16a0 <quadprog+0x560>
cmpq   $0x0,-0x28(%rbp)
je     11e4 <quadprog+0xa4>
cmpq   $0x0,-0x30(%rbp)
jne    11f5 <quadprog+0xb5>
cmpl   $0x0,-0x1c(%rbp)
je     11f5 <quadprog+0xb5>
movl   $0x0,-0x1c(%rbp)
cmpq   $0x0,0x18(%rbp)
je     120b <quadprog+0xcb>
cmpq   $0x0,0x20(%rbp)
jne    121c <quadprog+0xdc>
cmpl   $0x0,0x10(%rbp)
je     121c <quadprog+0xdc>
movl   $0x0,0x10(%rbp)
mov    -0x1c(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     12ee <quadprog+0x1ae>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    12aa <quadprog+0x16a>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126c <quadprog+0x12c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12e9 <quadprog+0x1a9>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b1 <quadprog+0x171>
jmp    12ee <quadprog+0x1ae>
cmpl   $0x0,0x10(%rbp)
je     1422 <quadprog+0x2e2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    141d <quadprog+0x2dd>
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    140a <quadprog+0x2ca>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    0x10(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1368 <quadprog+0x228>
jmp    140f <quadprog+0x2cf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ff <quadprog+0x1bf>
jmp    1422 <quadprog+0x2e2>
cmpq   $0x0,0x28(%rbp)
je     14fb <quadprog+0x3bb>
mov    -0x48(%rbp),%rdi
mov    -0x1c(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    0x10(%rbp),%eax
shl    $0x1,%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14f6 <quadprog+0x3b6>
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    0x10(%rbp),%edx
shl    $0x1,%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xb5d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    0x10(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1471 <quadprog+0x331>
jmp    14fb <quadprog+0x3bb>
cmpq   $0x0,0x30(%rbp)
je     15e3 <quadprog+0x4a3>
mov    -0x48(%rbp),%rdi
mov    -0x1c(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    0x10(%rbp),%eax
shl    $0x1,%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x3c(%rbp),%eax
imul   -0x3c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    15de <quadprog+0x49e>
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    0x10(%rbp),%edx
shl    $0x1,%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
mov    -0x38(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xa63(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    0x10(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    155a <quadprog+0x41a>
jmp    15e3 <quadprog+0x4a3>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%r9d
mov    -0x40(%rbp),%r11d
mov    -0x60(%rbp),%r10
xor    %r8d,%r8d
lea    -0x68(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <quadprog_ineq@plt>
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    166e <quadprog+0x52e>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x38(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1636 <quadprog+0x4f6>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quadprog>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edi,%ebx
xor    %edi,%edi
cmpq   $0x0,0xf8(%rsp)
mov    %ebx,%eax
cmove  %edi,%eax
mov    %rax,0x50(%rsp)
cmpq   $0x0,0x100(%rsp)
cmovne %ebx,%edi
mov    $0xfffffffe,%r15d
test   %rsi,%rsi
je     19f5 <quadprog+0x8b5>
test   %rdx,%rdx
je     19f5 <quadprog+0x8b5>
mov    %r9,%r13
mov    %r8,%r12
mov    %rsi,0x68(%rsp)
mov    %rdx,0x70(%rsp)
xor    %eax,%eax
test   %r9,%r9
mov    %ecx,%r14d
cmove  %eax,%r14d
test   %r8,%r8
cmove  %eax,%r14d
test   %ecx,%ecx
cmove  %ecx,%r14d
mov    0xe0(%rsp),%ecx
cmpq   $0x0,0xf0(%rsp)
mov    %ecx,%edx
cmove  %eax,%edx
mov    0xe8(%rsp),%r15
test   %r15,%r15
cmove  %eax,%edx
test   %ecx,%ecx
cmove  %ecx,%edx
mov    %rdx,0x20(%rsp)
lea    (%r14,%rdx,2),%ecx
mov    0x50(%rsp),%rax
mov    %rcx,0x28(%rsp)
add    %ecx,%eax
mov    %rax,0x58(%rsp)
mov    %rdi,0x30(%rsp)
lea    (%rax,%rdi,1),%ebp
lea    0x0(,%rbx,8),%edi
mov    %edi,0x44(%rsp)
imul   %ebp,%edi
mov    %rbx,0x18(%rsp)
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    %rbp,0x60(%rsp)
lea    0x0(,%rbp,8),%edi
call   1060 <malloc@plt>
mov    0x18(%rsp),%rsi
mov    %r14,0x10(%rsp)
test   %r14d,%r14d
mov    %rax,0x8(%rsp)
je     13d9 <quadprog+0x299>
mov    0x10(%rsp),%rax
mov    %eax,%ecx
imul   %esi,%ecx
test   %ecx,%ecx
jle    1308 <quadprog+0x1c8>
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1263 <quadprog+0x123>
xor    %ecx,%ecx
jmp    12f0 <quadprog+0x1b0>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1a17 <quadprog+0x8d7>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
cvtps2pd (%r12,%rsi,4),%xmm0
cvtps2pd 0x8(%r12,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,8)
movups %xmm1,0x10(%rbx,%rsi,8)
cvtps2pd 0x10(%r12,%rsi,4),%xmm0
cvtps2pd 0x18(%r12,%rsi,4),%xmm1
movups %xmm0,0x20(%rbx,%rsi,8)
movups %xmm1,0x30(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1290 <quadprog+0x150>
test   $0x1,%dl
je     12dd <quadprog+0x19d>
cvtps2pd (%r12,%rsi,4),%xmm0
cvtps2pd 0x8(%r12,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,8)
movups %xmm1,0x10(%rbx,%rsi,8)
cmp    %rax,%rcx
mov    0x18(%rsp),%rsi
je     1308 <quadprog+0x1c8>
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12f0 <quadprog+0x1b0>
cmpl   $0x0,0x10(%rsp)
mov    0x8(%rsp),%rax
jle    13d9 <quadprog+0x299>
mov    0x10(%rsp),%rax
mov    %eax,%edx
cmp    $0x4,%eax
jae    1330 <quadprog+0x1f0>
xor    %ecx,%ecx
mov    0x8(%rsp),%rax
jmp    13c0 <quadprog+0x280>
mov    %edx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1a27 <quadprog+0x8e7>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x8(%rsp),%rax
nopl   0x0(%rax,%rax,1)
cvtps2pd 0x0(%r13,%rsi,4),%xmm0
cvtps2pd 0x8(%r13,%rsi,4),%xmm1
movups %xmm0,(%rax,%rsi,8)
movups %xmm1,0x10(%rax,%rsi,8)
cvtps2pd 0x10(%r13,%rsi,4),%xmm0
cvtps2pd 0x18(%r13,%rsi,4),%xmm1
movups %xmm0,0x20(%rax,%rsi,8)
movups %xmm1,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1360 <quadprog+0x220>
test   $0x1,%r8b
je     13b0 <quadprog+0x270>
cvtps2pd 0x0(%r13,%rsi,4),%xmm0
cvtps2pd 0x8(%r13,%rsi,4),%xmm1
movups %xmm0,(%rax,%rsi,8)
movups %xmm1,0x10(%rax,%rsi,8)
cmp    %rdx,%rcx
mov    0x18(%rsp),%rsi
je     13d9 <quadprog+0x299>
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    13c0 <quadprog+0x280>
mov    %esi,%ebp
cmpl   $0x0,0x20(%rsp)
jle    15fc <quadprog+0x4bc>
mov    %rax,%r12
mov    0x10(%rsp),%rax
mov    %eax,%r10d
imul   %esi,%r10d
movslq %eax,%rcx
mov    %rcx,0x38(%rsp)
movslq %esi,%r13
mov    0x20(%rsp),%rcx
mov    %ecx,%edx
mov    %rdx,0x98(%rsp)
lea    -0x1(%rbp),%rdx
mov    %rdx,0x88(%rsp)
lea    (%rcx,%rax,1),%r8d
imul   %esi,%r8d
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x78(%rsp)
mov    %ebp,%r9d
and    $0xfffffffc,%r9d
lea    0x8(%r15),%rdi
shl    $0x2,%r13
xor    %ecx,%ecx
movaps 0xbbc(%rip),%xmm0
mov    %r10,0x90(%rsp)
mov    %r8,0x80(%rsp)
mov    %r13,0x48(%rsp)
jmp    147e <quadprog+0x33e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %r13,%rdi
add    %rbp,%r8
add    %rbp,%r10
add    %r13,%r15
cmp    0x98(%rsp),%rcx
je     15fc <quadprog+0x4bc>
mov    0x38(%rsp),%rax
add    %rcx,%rax
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,1),%esi
mov    0xf0(%rsp),%rdx
movss  (%rdx,%rcx,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movsd  %xmm2,(%r12,%rax,8)
xorps  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
movslq %esi,%rax
mov    0x18(%rsp),%rdx
movsd  %xmm1,(%r12,%rax,8)
test   %edx,%edx
jle    1460 <quadprog+0x320>
cmp    $0x4,%edx
jae    1510 <quadprog+0x3d0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
lea    (%r10,%rax,1),%edx
movslq %edx,%rdx
movsd  %xmm2,(%rbx,%rdx,8)
xorps  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
lea    (%r8,%rax,1),%edx
movslq %edx,%rdx
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    14d0 <quadprog+0x390>
jmp    1460 <quadprog+0x320>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%r11d
imul   %ebp,%r11d
mov    0x90(%rsp),%rax
lea    (%rax,%r11,1),%r14d
mov    0x88(%rsp),%rdx
lea    (%r14,%rdx,1),%eax
cmp    %r14d,%eax
jl     14c6 <quadprog+0x386>
mov    %rdx,%r12
shr    $0x20,%r12
jne    1592 <quadprog+0x452>
add    0x80(%rsp),%r11d
lea    (%r11,%rdx,1),%eax
cmp    %r11d,%eax
jl     1592 <quadprog+0x452>
mov    $0x0,%eax
test   %r12,%r12
mov    0x8(%rsp),%r12
jne    14d0 <quadprog+0x390>
movslq %r14d,%r13
lea    (%rbx,%r13,8),%r14
movslq %r11d,%rsi
mov    0x78(%rsp),%rax
lea    (%rax,%rsi,8),%rdx
cmp    %rdx,%r14
jae    159e <quadprog+0x45e>
lea    (%rax,%r13,8),%rax
lea    (%rbx,%rsi,8),%rdx
cmp    %rax,%rdx
jae    159e <quadprog+0x45e>
xor    %eax,%eax
mov    0x48(%rsp),%r13
jmp    14d0 <quadprog+0x390>
xor    %eax,%eax
mov    0x8(%rsp),%r12
jmp    14d0 <quadprog+0x390>
xor    %eax,%eax
movsd  -0x8(%rdi,%rax,4),%xmm1
movsd  (%rdi,%rax,4),%xmm2
cvtps2pd %xmm1,%xmm3
cvtps2pd %xmm2,%xmm4
lea    (%r10,%rax,1),%edx
movslq %edx,%rdx
movups %xmm3,(%rbx,%rdx,8)
movups %xmm4,0x10(%rbx,%rdx,8)
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
cvtps2pd %xmm1,%xmm1
cvtps2pd %xmm2,%xmm2
lea    (%r8,%rax,1),%edx
movslq %edx,%rdx
movups %xmm1,(%rbx,%rdx,8)
movups %xmm2,0x10(%rbx,%rdx,8)
add    $0x4,%rax
cmp    %rax,%r9
jne    15a0 <quadprog+0x460>
mov    %r9,%rax
cmp    %rbp,%r9
mov    0x48(%rsp),%r13
jne    14d0 <quadprog+0x390>
jmp    1460 <quadprog+0x320>
mov    0x20(%rsp),%rax
add    %eax,%eax
mov    %rax,0x20(%rsp)
cmpq   $0x0,0xf8(%rsp)
mov    0x100(%rsp),%r14
mov    0x50(%rsp),%r13
je     1765 <quadprog+0x625>
mov    0x10(%rsp),%rax
mov    %eax,%r12d
mov    0x18(%rsp),%rcx
imul   %ecx,%r12d
movslq %r12d,%rax
lea    (%rbx,%rax,8),%rax
mov    0x20(%rsp),%rdx
mov    %edx,%r15d
imul   %ecx,%r15d
movslq %r15d,%rcx
lea    (%rax,%rcx,8),%rdi
mov    %r13d,%edx
imul   %r13d,%edx
shl    $0x3,%edx
xor    %esi,%esi
call   1040 <memset@plt>
test   %r13d,%r13d
jle    1765 <quadprog+0x625>
mov    %r13d,%r10d
cmp    $0x1,%r13d
mov    %r10,0x38(%rsp)
jne    167e <quadprog+0x53e>
xor    %eax,%eax
jmp    1714 <quadprog+0x5d4>
and    $0xfffffffe,%r10d
lea    0x1(%r13),%r9d
mov    0x18(%rsp),%rdi
imul   0x28(%rsp),%edi
lea    0x2(%r13,%r13,1),%r11d
movslq 0x10(%rsp),%rax
movslq 0x20(%rsp),%rdx
add    %rax,%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%rdx,8),%rsi
add    $0x8,%rsi
xor    %eax,%eax
movabs $0xbff0000000000000,%rdx
movaps 0x93e(%rip),%xmm0
mov    0xf8(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    %rdx,(%rbx,%rdi,8)
movss  (%r8,%rax,4),%xmm1
xorps  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x8(%rsi,%rax,8)
lea    (%r9,%rdi,1),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rbx,%rcx,8)
movss  0x4(%r8,%rax,4),%xmm1
xorps  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
add    $0x2,%rax
add    %r11d,%edi
cmp    %rax,%r10
jne    16d0 <quadprog+0x590>
testb  $0x1,0x38(%rsp)
je     1765 <quadprog+0x625>
add    %r12d,%r15d
add    %eax,%r15d
mov    %r13d,%ecx
imul   %eax,%ecx
add    %r15d,%ecx
movslq %ecx,%rcx
movabs $0xbff0000000000000,%rdx
mov    %rdx,(%rbx,%rcx,8)
mov    0xf8(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
xorps  0x8b1(%rip),%xmm0
movslq 0x28(%rsp),%rcx
cvtss2sd %xmm0,%xmm0
add    %rax,%rcx
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
test   %r14,%r14
je     18a1 <quadprog+0x761>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rax
imul   %ecx,%eax
mov    %rax,0x10(%rsp)
cltq
lea    (%rbx,%rax,8),%rax
mov    0x20(%rsp),%rdx
imul   %ecx,%edx
mov    %rdx,%r12
movslq %edx,%rcx
lea    (%rax,%rcx,8),%rax
imul   %r13d,%r13d
lea    (%rax,%r13,8),%rdi
mov    0x30(%rsp),%r15
mov    %r15d,%edx
imul   %r15d,%edx
shl    $0x3,%edx
xor    %esi,%esi
call   1040 <memset@plt>
test   %r15d,%r15d
jle    18a1 <quadprog+0x761>
movslq 0x58(%rsp),%r8
mov    0x30(%rsp),%rcx
mov    %ecx,%r9d
cmp    $0x1,%ecx
jne    17d8 <quadprog+0x698>
xor    %ecx,%ecx
jmp    185d <quadprog+0x71d>
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
lea    0x1(%rcx),%r10d
mov    0x28(%rsp),%rax
imul   0x18(%rsp),%eax
add    %r13d,%eax
lea    (%rcx,%rcx,1),%r15d
add    $0x2,%r15d
mov    0x8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdx
add    $0x8,%rdx
xor    %ecx,%ecx
movabs $0x3ff0000000000000,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cltq
mov    %rdi,(%rbx,%rax,8)
movss  (%r14,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
lea    (%r10,%rax,1),%esi
movslq %esi,%rsi
mov    %rdi,(%rbx,%rsi,8)
movss  0x4(%r14,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rcx
add    %r15d,%eax
cmp    %rcx,%r11
jne    1820 <quadprog+0x6e0>
test   $0x1,%r9b
je     18a1 <quadprog+0x761>
add    0x10(%rsp),%r13d
add    %r12d,%r13d
add    %ecx,%r13d
mov    0x30(%rsp),%rax
imul   %ecx,%eax
add    %r13d,%eax
cltq
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rbx,%rax,8)
movss  (%r14,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
add    %rcx,%r8
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax,%r8,8)
mov    0x110(%rsp),%r13
mov    0x44(%rsp),%edi
call   1060 <malloc@plt>
mov    %rax,%r12
sub    $0x8,%rsp
lea    0xa8(%rsp),%rax
mov    0x70(%rsp),%rdi
mov    0x78(%rsp),%rsi
mov    %rbx,%rdx
mov    0x10(%rsp),%rcx
xor    %r8d,%r8d
mov    0x20(%rsp),%r14
mov    %r14d,%r9d
push   %rax
push   %r12
push   0x78(%rsp)
call   1050 <quadprog_ineq@plt>
add    $0x20,%rsp
mov    %eax,%r15d
test   %r14d,%r14d
jle    19c8 <quadprog+0x888>
mov    0x108(%rsp),%rax
cmp    $0x4,%r14d
jae    190f <quadprog+0x7cf>
xor    %ecx,%ecx
jmp    19b0 <quadprog+0x870>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1a0a <quadprog+0x8ca>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r12,%rsi,8),%xmm0
movupd 0x10(%r12,%rsi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rax,%rsi,4)
movupd 0x20(%r12,%rsi,8),%xmm0
movupd 0x30(%r12,%rsi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%rax,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1940 <quadprog+0x800>
test   $0x1,%dl
je     19ab <quadprog+0x86b>
movupd (%r12,%rsi,8),%xmm0
movupd 0x10(%r12,%rsi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rax,%rsi,4)
cmp    %rbp,%rcx
je     19c8 <quadprog+0x888>
movsd  (%r12,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    19b0 <quadprog+0x870>
mov    %r12,%rdi
call   1030 <free@plt>
movsd  0xa0(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%r13)
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r15d,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    198d <quadprog+0x84d>
jmp    19ab <quadprog+0x86b>
xor    %esi,%esi
test   $0x1,%dl
jne    12c9 <quadprog+0x189>
jmp    12dd <quadprog+0x19d>
xor    %esi,%esi
mov    0x8(%rsp),%rax
test   $0x1,%r8b
jne    139b <quadprog+0x25b>
jmp    13b0 <quadprog+0x270>

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

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