#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 DBL_MAX;
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int adatron(long *y, double *K, int n, double C, int maxsteps, double eps,
            double *alpha, double *margin) {
  double *z = NULL;
  double delta;
  int i, j, k;
  double zplus, zminus;
  int nplus, nminus;
  z = (double *)malloc(n * sizeof(double));
  for (i = 0; i < maxsteps; i++) {
    for (j = 0; j < n; j++) {
      z[j] = 0.0;
      for (k = 0; k < n; k++)
        z[j] += alpha[k] * y[k] * K[j + (k * n)];
      delta = (1 - (y[j] * z[j])) / K[j + (j * n)];
      alpha[j] = ((((0) > (alpha[j] + delta) ? (0) : (alpha[j] + delta))) < (C)
                      ? (((0) > (alpha[j] + delta) ? (0) : (alpha[j] + delta)))
                      : (C));
    }
    zplus = DBL_MAX;
    zminus = -DBL_MAX;
    nplus = 0;
    nminus = 0;
    for (k = 0; k < n; k++) {
      if ((y[k] == +1) && (alpha[k] < C)) {
        zplus = ((zplus) < (z[k]) ? (zplus) : (z[k]));
        nplus++;
      }
      if ((y[k] == -1) && (alpha[k] < C)) {
        zminus = ((zminus) > (z[k]) ? (zminus) : (z[k]));
        nminus++;
      }
    }
    if ((nplus == 0) || (nminus == 0))
      *margin = 0.0;
    else
      *margin = 0.5 * (zplus - zminus);
    if (fabs(1.0 - *margin) < eps)
      break;
  }
  free(z);
  return i;
}


x86 assembly (clang, -O0):
<adatron>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    154d <adatron+0x42d>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1352 <adatron+0x232>
mov    -0x48(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    120e <adatron+0xee>
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
cvtsi2sdq (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11a3 <adatron+0x83>
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
cvtsi2sdq (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xdbc(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x50(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1299 <adatron+0x179>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    12b0 <adatron+0x190>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1322 <adatron+0x202>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x50(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    12f3 <adatron+0x1d3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    130d <adatron+0x1ed>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    132f <adatron+0x20f>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1180 <adatron+0x60>
mov    0x2c87(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x2c77(%rip),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14c9 <adatron+0x3a9>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    1432 <adatron+0x312>
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1432 <adatron+0x312>
movsd  -0x68(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1407 <adatron+0x2e7>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    141c <adatron+0x2fc>
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
cmpq   $0xffffffffffffffff,(%rax,%rcx,8)
jne    14b6 <adatron+0x396>
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14b6 <adatron+0x396>
movsd  -0x70(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    148b <adatron+0x36b>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    14a0 <adatron+0x380>
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14bb <adatron+0x39b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    139e <adatron+0x27e>
cmpl   $0x0,-0x74(%rbp)
je     14dd <adatron+0x3bd>
cmpl   $0x0,-0x78(%rbp)
jne    14ed <adatron+0x3cd>
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    150b <adatron+0x3eb>
movsd  -0x68(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
movsd  0xb01(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movsd  0xaf1(%rip),%xmm1
subsd  (%rax),%xmm1
movaps 0xaee(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    153a <adatron+0x41a>
jmp    154d <adatron+0x42d>
jmp    153f <adatron+0x41f>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    116d <adatron+0x4d>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x54(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<adatron>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,%rbx
movsd  %xmm1,0x10(%rsp)
mov    %ecx,%r14d
movapd %xmm0,0x20(%rsp)
mov    %edx,%r12d
mov    %rsi,%r13
mov    %rdi,%rbp
lea    0x0(,%r12,8),%edi
call   1040 <malloc@plt>
mov    %r14d,0xc(%rsp)
test   %r14d,%r14d
jle    13f1 <adatron+0x2d1>
movslq %r12d,%rcx
mov    %r12d,%r8d
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
mov    %rcx,%r15
shl    $0x4,%r15
xor    %r14d,%r14d
movsd  0xe98(%rip),%xmm0
xorpd  %xmm1,%xmm1
movapd 0xe6b(%rip),%xmm8
movsd  0xe8a(%rip),%xmm9
movapd 0xe69(%rip),%xmm10
movsd  0x10(%rsp),%xmm3
movapd 0x20(%rsp),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r12d,%r12d
jle    1380 <adatron+0x260>
mov    %r13,%r10
xor    %edx,%edx
jmp    11fb <adatron+0xdb>
cmpltsd %xmm1,%xmm5
movapd %xmm5,%xmm2
andnpd %xmm7,%xmm2
andpd  %xmm6,%xmm5
orpd   %xmm2,%xmm5
movlpd %xmm5,(%rbx,%rdx,8)
add    $0x1,%rdx
add    $0x8,%r10
cmp    %r8,%rdx
je     1300 <adatron+0x1e0>
movq   $0x0,(%rax,%rdx,8)
xorpd  %xmm5,%xmm5
cmp    $0x1,%r12d
jne    1220 <adatron+0x100>
xor    %esi,%esi
jmp    1276 <adatron+0x156>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r10,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm6,%xmm6
cvtsi2sdq 0x0(%rbp,%rsi,8),%xmm6
mulsd  (%rbx,%rsi,8),%xmm6
mulsd  (%rdi),%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%rax,%rdx,8)
xorps  %xmm5,%xmm5
cvtsi2sdq 0x8(%rbp,%rsi,8),%xmm5
mulsd  0x8(%rbx,%rsi,8),%xmm5
mulsd  (%rdi,%rcx,8),%xmm5
addsd  %xmm6,%xmm5
movsd  %xmm5,(%rax,%rdx,8)
add    $0x2,%rsi
add    %r15,%rdi
cmp    %rsi,%r9
jne    1230 <adatron+0x110>
test   $0x1,%r8b
je     12a2 <adatron+0x182>
xorps  %xmm6,%xmm6
cvtsi2sdq 0x0(%rbp,%rsi,8),%xmm6
mulsd  (%rbx,%rsi,8),%xmm6
imul   %rcx,%rsi
add    %rdx,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm6
addsd  %xmm6,%xmm5
movsd  %xmm5,(%rax,%rdx,8)
xorps  %xmm6,%xmm6
cvtsi2sdq 0x0(%rbp,%rdx,8),%xmm6
mulsd  %xmm5,%xmm6
movapd %xmm0,%xmm5
subsd  %xmm6,%xmm5
mov    %rdx,%rsi
imul   %rcx,%rsi
add    %rdx,%rsi
divsd  0x0(%r13,%rsi,8),%xmm5
addsd  (%rbx,%rdx,8),%xmm5
xorpd  %xmm6,%xmm6
maxsd  %xmm5,%xmm6
ucomisd %xmm6,%xmm4
cmpnltsd %xmm4,%xmm6
andpd  %xmm4,%xmm6
movapd %xmm6,%xmm7
jbe    11d0 <adatron+0xb0>
movapd %xmm5,%xmm7
jmp    11d0 <adatron+0xb0>
cs nopw 0x0(%rax,%rax,1)
mov    0x2cd9(%rip),%rdx
movsd  (%rdx),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm8,%xmm6
test   %r12d,%r12d
jle    1394 <adatron+0x274>
xor    %edx,%edx
xor    %r11d,%r11d
xor    %r10d,%r10d
jmp    1339 <adatron+0x219>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
cmp    %rdx,%r8
je     139a <adatron+0x27a>
mov    0x0(%rbp,%rdx,8),%rsi
cmp    $0xffffffffffffffff,%rsi
je     1360 <adatron+0x240>
cmp    $0x1,%rsi
jne    1330 <adatron+0x210>
ucomisd (%rbx,%rdx,8),%xmm4
jbe    1330 <adatron+0x210>
minsd  (%rax,%rdx,8),%xmm5
add    $0x1,%r10d
jmp    1330 <adatron+0x210>
nopl   0x0(%rax)
ucomisd (%rbx,%rdx,8),%xmm4
jbe    1330 <adatron+0x210>
maxsd  (%rax,%rdx,8),%xmm6
add    $0x1,%r11d
jmp    1330 <adatron+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x2c59(%rip),%rdx
movsd  (%rdx),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm8,%xmm6
xor    %r10d,%r10d
xor    %r11d,%r11d
subsd  %xmm6,%xmm5
mulsd  %xmm9,%xmm5
xorpd  %xmm6,%xmm6
xorpd  %xmm7,%xmm7
test   %r11d,%r11d
je     13b4 <adatron+0x294>
movapd %xmm5,%xmm7
test   %r10d,%r10d
je     13bd <adatron+0x29d>
movapd %xmm7,%xmm6
mov    0x18(%rsp),%rdx
movsd  %xmm6,(%rdx)
movapd %xmm0,%xmm2
subsd  %xmm6,%xmm2
andpd  %xmm10,%xmm2
ucomisd %xmm2,%xmm3
ja     13f4 <adatron+0x2d4>
add    $0x1,%r14d
cmp    0xc(%rsp),%r14d
jne    11c0 <adatron+0xa0>
mov    0xc(%rsp),%ecx
mov    %ecx,%r14d
jmp    13f4 <adatron+0x2d4>
xor    %r14d,%r14d
mov    %rax,%rdi
call   1030 <free@plt>
mov    %r14d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@DBL_MAX = global double 0.000000e+00
define i32 @adatron(i64* nocapture %0, double* nocapture %1, i32 %2, double %3, i32 %4, double %5, double* nocapture %6, double* nocapture writeonly %7) {
%9 = shl i32 %2, 3
%10 = tail call i64 @malloc(i32 %9)
%11 = inttoptr i64 %10 to double*
%12 = icmp sgt i32 %4, 0
br i1 %12, label %13, label %154
13: ; preds = %8
%14 = icmp sgt i32 %2, 0
%15 = sext i32 %2 to i64
%16 = zext i32 %2 to i64
%17 = zext i32 %2 to i64
%18 = and i64 %16, 1
%19 = icmp eq i32 %2, 1
%20 = and i64 %16, 4294967294
%21 = icmp eq i64 %18, 0
br label %22
22: ; preds = %13, %151
%23 = phi i32 [ 0, %13 ], [ %152, %151 ]
br i1 %14, label %27, label %24
24: ; preds = %22
%25 = load double, double* @DBL_MAX
%26 = fneg double %25
br label %137
27: ; preds = %22, %76
%28 = phi i64 [ %97, %76 ], [ 0, %22 ]
%29 = getelementptr inbounds double, double* %11, i64 %28
store double 0.000000e+00, double* %29
br i1 %19, label %60, label %30
30: ; preds = %27, %30
%31 = phi double [ %56, %30 ], [ 0.000000e+00, %27 ]
%32 = phi i64 [ %57, %30 ], [ 0, %27 ]
%33 = phi i64 [ %58, %30 ], [ 0, %27 ]
%34 = getelementptr inbounds double, double* %6, i64 %32
%35 = load double, double* %34
%36 = getelementptr inbounds i64, i64* %0, i64 %32
%37 = load i64, i64* %36
%38 = sitofp i64 %37 to double
%39 = fmul double %35, %38
%40 = mul nsw i64 %32, %15
%41 = add nsw i64 %40, %28
%42 = getelementptr inbounds double, double* %1, i64 %41
%43 = load double, double* %42
%44 = tail call double @llvm.fmuladd.f64(double %39, double %43, double %31)
store double %44, double* %29
%45 = or i64 %32, 1
%46 = getelementptr inbounds double, double* %6, i64 %45
%47 = load double, double* %46
%48 = getelementptr inbounds i64, i64* %0, i64 %45
%49 = load i64, i64* %48
%50 = sitofp i64 %49 to double
%51 = fmul double %47, %50
%52 = mul nsw i64 %45, %15
%53 = add nsw i64 %52, %28
%54 = getelementptr inbounds double, double* %1, i64 %53
%55 = load double, double* %54
%56 = tail call double @llvm.fmuladd.f64(double %51, double %55, double %44)
store double %56, double* %29
%57 = add nuw nsw i64 %32, 2
%58 = add i64 %33, 2
%59 = icmp eq i64 %58, %20
br i1 %59, label %60, label %30
60: ; preds = %30, %27
%61 = phi double [ undef, %27 ], [ %56, %30 ]
%62 = phi double [ 0.000000e+00, %27 ], [ %56, %30 ]
%63 = phi i64 [ 0, %27 ], [ %57, %30 ]
br i1 %21, label %76, label %64
64: ; preds = %60
%65 = getelementptr inbounds double, double* %6, i64 %63
%66 = load double, double* %65
%67 = getelementptr inbounds i64, i64* %0, i64 %63
%68 = load i64, i64* %67
%69 = sitofp i64 %68 to double
%70 = fmul double %66, %69
%71 = mul nsw i64 %63, %15
%72 = add nsw i64 %71, %28
%73 = getelementptr inbounds double, double* %1, i64 %72
%74 = load double, double* %73
%75 = tail call double @llvm.fmuladd.f64(double %70, double %74, double %62)
store double %75, double* %29
br label %76
76: ; preds = %60, %64
%77 = phi double [ %61, %60 ], [ %75, %64 ]
%78 = getelementptr inbounds i64, i64* %0, i64 %28
%79 = load i64, i64* %78
%80 = sitofp i64 %79 to double
%81 = fneg double %80
%82 = tail call double @llvm.fmuladd.f64(double %81, double %77, double 1.000000e+00)
%83 = mul nsw i64 %28, %15
%84 = add nsw i64 %83, %28
%85 = getelementptr inbounds double, double* %1, i64 %84
%86 = load double, double* %85
%87 = fdiv double %82, %86
%88 = getelementptr inbounds double, double* %6, i64 %28
%89 = load double, double* %88
%90 = fadd double %89, %87
%91 = fcmp olt double %90, 0.000000e+00
%92 = select i1 %91, double 0.000000e+00, double %90
%93 = fcmp uge double %92, %3
%94 = or i1 %91, %93
%95 = select i1 %93, double %3, double 0.000000e+00
%96 = select i1 %94, double %95, double %90
store double %96, double* %88
%97 = add nuw nsw i64 %28, 1
%98 = icmp eq i64 %97, %16
br i1 %98, label %99, label %27
99: ; preds = %76
%100 = load double, double* @DBL_MAX
%101 = fneg double %100
br i1 %14, label %102, label %137
102: ; preds = %99, %130
%103 = phi i64 [ %135, %130 ], [ 0, %99 ]
%104 = phi i32 [ %134, %130 ], [ 0, %99 ]
%105 = phi i32 [ %131, %130 ], [ 0, %99 ]
%106 = phi double [ %133, %130 ], [ %101, %99 ]
%107 = phi double [ %132, %130 ], [ %100, %99 ]
%108 = getelementptr inbounds i64, i64* %0, i64 %103
%109 = load i64, i64* %108
switch i64 %109, label %130 [
i64 1, label %110
i64 -1, label %120
]
110: ; preds = %102
%111 = getelementptr inbounds double, double* %6, i64 %103
%112 = load double, double* %111
%113 = fcmp olt double %112, %3
br i1 %113, label %114, label %130
114: ; preds = %110
%115 = getelementptr inbounds double, double* %11, i64 %103
%116 = load double, double* %115
%117 = fcmp olt double %107, %116
%118 = select i1 %117, double %107, double %116
%119 = add nsw i32 %105, 1
br label %130
120: ; preds = %102
%121 = getelementptr inbounds double, double* %6, i64 %103
%122 = load double, double* %121
%123 = fcmp olt double %122, %3
br i1 %123, label %124, label %130
124: ; preds = %120
%125 = getelementptr inbounds double, double* %11, i64 %103
%126 = load double, double* %125
%127 = fcmp ogt double %106, %126
%128 = select i1 %127, double %106, double %126
%129 = add nsw i32 %104, 1
br label %130
130: ; preds = %102, %110, %114, %120, %124
%131 = phi i32 [ %105, %124 ], [ %105, %120 ], [ %105, %110 ], [ %119, %114 ], [ %105, %102 ]
%132 = phi double [ %107, %124 ], [ %107, %120 ], [ %107, %110 ], [ %118, %114 ], [ %107, %102 ]
%133 = phi double [ %128, %124 ], [ %106, %120 ], [ %106, %110 ], [ %106, %114 ], [ %106, %102 ]
%134 = phi i32 [ %129, %124 ], [ %104, %120 ], [ %104, %110 ], [ %104, %114 ], [ %104, %102 ]
%135 = add nuw nsw i64 %103, 1
%136 = icmp eq i64 %135, %17
br i1 %136, label %137, label %102
137: ; preds = %130, %24, %99
%138 = phi double [ %100, %99 ], [ %25, %24 ], [ %132, %130 ]
%139 = phi double [ %101, %99 ], [ %26, %24 ], [ %133, %130 ]
%140 = phi i32 [ 0, %99 ], [ 0, %24 ], [ %131, %130 ]
%141 = phi i32 [ 0, %99 ], [ 0, %24 ], [ %134, %130 ]
%142 = icmp eq i32 %140, 0
%143 = icmp eq i32 %141, 0
%144 = select i1 %142, i1 true, i1 %143
%145 = fsub double %138, %139
%146 = fmul double %145, 5.000000e-01
%147 = select i1 %144, double 0.000000e+00, double %146
store double %147, double* %7
%148 = fsub double 1.000000e+00, %147
%149 = tail call double @llvm.fabs.f64(double %148)
%150 = fcmp olt double %149, %5
br i1 %150, label %154, label %151
151: ; preds = %137
%152 = add nuw nsw i32 %23, 1
%153 = icmp eq i32 %152, %4
br i1 %153, label %154, label %22
154: ; preds = %151, %137, %8
%155 = phi i32 [ 0, %8 ], [ %23, %137 ], [ %4, %151 ]
%156 = tail call i32 @free(double* %11)
ret i32 %155
}