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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ mrqmin(double *, double *, double *, int, double *, int *,
                          int, double *, double *, int);
double sqrt(double);
int gaussfit(double *y, double *a, int nPts, int MA) {
  int i, iter, itst, k, mfit = MA;
  int getmem;
  double alamda, chisq, ochisq;
  double x[76], sig[76];
  int ia[4];
  for (i = 1; i <= nPts; i++) {
    x[i] = (double)(i);
    sig[i] = (sqrt(y[i] * 0.001));
    if (sig[i] <= 0.00)
      sig[i] = .3;
    else {
      sig[i] = 1.0 / sqrt((double)(sig[i]));
    }
  }
  ia[1] = 0;
  for (i = 2; i <= mfit; i++)
    ia[i] = 1;
  for (iter = 1; iter <= 2; iter++) {
    alamda = -1;
    getmem = 1;
    mrqmin(x, y, sig, nPts, a, ia, MA, &chisq, &alamda, getmem);
    k = 1;
    itst = 0;
    for (;;) {
      getmem = 0;
      k++;
      ochisq = chisq;
      mrqmin(x, y, sig, nPts, a, ia, MA, &chisq, &alamda, getmem);
      itst++;
      if (itst < 4)
        continue;
      alamda = 0.0;
      getmem = -1;
      mrqmin(x, y, sig, nPts, a, ia, MA, &chisq, &alamda, getmem);
      break;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<gaussfit>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x538,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11fd <gaussfit+0xdd>
cvtsi2sdl -0x24(%rbp),%xmm0
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0xe93(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
call   1040 <sqrt@plt>
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x510(%rbp,%rax,8)
ff ff
movslq -0x24(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd -0x510(%rbp,%rax,8),%xmm0
ff ff
jb     11bc <gaussfit+0x9c>
movslq -0x24(%rbp),%rax
movsd  0xe6a(%rip),%xmm0
movsd  %xmm0,-0x510(%rbp,%rax,8)
ff ff
jmp    11ea <gaussfit+0xca>
movslq -0x24(%rbp),%rax
movsd  -0x510(%rbp,%rax,8),%xmm0
ff ff
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe37(%rip),%xmm0
divsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x510(%rbp,%rax,8)
ff ff
jmp    11ef <gaussfit+0xcf>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1147 <gaussfit+0x27>
movl   $0x0,-0x51c(%rbp)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1237 <gaussfit+0x117>
movslq -0x24(%rbp),%rax
movl   $0x1,-0x520(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    120e <gaussfit+0xee>
movl   $0x1,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jg     138a <gaussfit+0x26a>
movsd  0xdb0(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x38(%rbp)
lea    -0x2b0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x510(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%r8
lea    -0x520(%rbp),%r9
mov    -0x20(%rbp),%ebx
mov    -0x38(%rbp),%eax
lea    -0x48(%rbp),%r11
lea    -0x40(%rbp),%r10
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1030 <mrqmin@plt>
movl   $0x1,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
lea    -0x2b0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x510(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%r8
lea    -0x520(%rbp),%r9
mov    -0x20(%rbp),%ebx
mov    -0x38(%rbp),%eax
lea    -0x48(%rbp),%r11
lea    -0x40(%rbp),%r10
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1030 <mrqmin@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    1324 <gaussfit+0x204>
jmp    12ae <gaussfit+0x18e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0xffffffff,-0x38(%rbp)
lea    -0x2b0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x510(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%r8
lea    -0x520(%rbp),%r9
mov    -0x20(%rbp),%ebx
mov    -0x38(%rbp),%eax
lea    -0x48(%rbp),%r11
lea    -0x40(%rbp),%r10
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1030 <mrqmin@plt>
jmp    137c <gaussfit+0x25c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    123e <gaussfit+0x11e>
xor    %eax,%eax
add    $0x538,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e8,%rsp
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,%r15
mov    %rdi,%r13
test   %edx,%edx
jle    11d3 <gaussfit+0xb3>
lea    0x1(%r12),%ebp
mov    $0x1,%ebx
xorpd  %xmm2,%xmm2
jmp    1187 <gaussfit+0x67>
cs nopw 0x0(%rax,%rax,1)
nop
call   1040 <sqrt@plt>
xorpd  %xmm2,%xmm2
movsd  0xe9f(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x280(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
je     11d3 <gaussfit+0xb3>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0x20(%rsp,%rbx,8)
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0xe5d(%rip),%xmm0
ucomisd %xmm2,%xmm0
jb     11b0 <gaussfit+0x90>
sqrtsd %xmm0,%xmm0
jmp    11b9 <gaussfit+0x99>
nop
call   1040 <sqrt@plt>
xorpd  %xmm2,%xmm2
ucomisd %xmm0,%xmm2
movsd  0xe43(%rip),%xmm1
jae    1175 <gaussfit+0x55>
ucomisd %xmm2,%xmm0
jb     1160 <gaussfit+0x40>
sqrtsd %xmm0,%xmm0
jmp    1169 <gaussfit+0x49>
movl   $0x0,0x14(%rsp)
cmp    $0x2,%r14d
jl     12c1 <gaussfit+0x1a1>
mov    %r14d,%eax
lea    -0x1(%rax),%rdx
mov    $0x2,%ecx
cmp    $0x8,%rdx
jb     12ab <gaussfit+0x18b>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1220 <gaussfit+0x100>
xor    %edi,%edi
jmp    126d <gaussfit+0x14d>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
movapd 0xdf2(%rip),%xmm0
xchg   %ax,%ax
movupd %xmm0,0x18(%rsp,%rdi,4)
movupd %xmm0,0x28(%rsp,%rdi,4)
movupd %xmm0,0x38(%rsp,%rdi,4)
movupd %xmm0,0x48(%rsp,%rdi,4)
movupd %xmm0,0x58(%rsp,%rdi,4)
movupd %xmm0,0x68(%rsp,%rdi,4)
movupd %xmm0,0x78(%rsp,%rdi,4)
movupd %xmm0,0x88(%rsp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1230 <gaussfit+0x110>
test   %rbp,%rbp
je     12a2 <gaussfit+0x182>
movapd 0xda6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
or     $0x8,%rsi
movupd %xmm0,0x10(%rsp,%rsi,1)
movupd %xmm0,0x20(%rsp,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    1280 <gaussfit+0x160>
cmp    %rcx,%rdx
je     12c1 <gaussfit+0x1a1>
or     $0x2,%rcx
add    $0x1,%rax
nop
movl   $0x1,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12b0 <gaussfit+0x190>
movabs $0xbff0000000000000,%rax
mov    %rax,(%rsp)
mov    %rsp,%rbp
lea    0x8(%rsp),%rbx
lea    0x20(%rsp),%rdi
lea    0x280(%rsp),%rdx
lea    0x10(%rsp),%r9
mov    %r13,%rsi
mov    %r12d,%ecx
mov    %r15,%r8
push   $0x1
push   %rbp
push   %rbx
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
lea    0x280(%rsp),%rdx
mov    %r12d,%ecx
mov    %r15,%r8
lea    0x10(%rsp),%r9
push   $0x0
push   %rbp
push   %rbx
mov    %rbx,%rbp
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
lea    0x280(%rsp),%rdx
mov    %r12d,%ecx
mov    %r15,%r8
lea    0x10(%rsp),%r9
mov    %r9,%rbx
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
push   %rbp
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
lea    0x280(%rsp),%rdx
mov    %rdx,%rbp
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
movq   $0x0,(%rsp)
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0xffffffffffffffff
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
movabs $0xbff0000000000000,%rax
mov    %rax,(%rsp)
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x1
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0x0
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
movq   $0x0,(%rsp)
lea    0x20(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %rbx,%r9
push   $0xffffffffffffffff
lea    0x8(%rsp),%rax
push   %rax
lea    0x18(%rsp),%rax
push   %rax
push   %r14
call   1030 <mrqmin@plt>
add    $0x20,%rsp
xor    %eax,%eax
add    $0x4e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @gaussfit(double* %0, double* %1, i32 %2, i32 %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca [76 x double]
%19 = alloca [76 x double]
%20 = alloca [4 x i32]
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%21 = load i32, i32* %8
store i32 %21, i32* %13
store i32 1, i32* %9
br label %22
22: ; preds = %62, %4
%23 = load i32, i32* %9
%24 = load i32, i32* %7
%25 = icmp sle i32 %23, %24
br i1 %25, label %26, label %65
26: ; preds = %22
%27 = load i32, i32* %9
%28 = sitofp i32 %27 to double
%29 = load i32, i32* %9
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [76 x double], [76 x double]* %18, i64 0, i64 %30
store double %28, double* %31
%32 = load double*, double** %5
%33 = load i32, i32* %9
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = fmul double %36, 1.000000e-03
%38 = call double @sqrt(double %37)
%39 = load i32, i32* %9
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 %40
store double %38, double* %41
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 %43
%45 = load double, double* %44
%46 = fcmp ole double %45, 0.000000e+00
br i1 %46, label %47, label %51
47: ; preds = %26
%48 = load i32, i32* %9
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 %49
store double 3.000000e-01, double* %50
br label %61
51: ; preds = %26
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 %53
%55 = load double, double* %54
%56 = call double @sqrt(double %55)
%57 = fdiv double 1.000000e+00, %56
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 %59
store double %57, double* %60
br label %61
61: ; preds = %51, %47
br label %62
62: ; preds = %61
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 1
store i32 %64, i32* %9
br label %22
65: ; preds = %22
%66 = getelementptr inbounds [4 x i32], [4 x i32]* %20, i64 0, i64 1
store i32 0, i32* %66
store i32 2, i32* %9
br label %67
67: ; preds = %75, %65
%68 = load i32, i32* %9
%69 = load i32, i32* %13
%70 = icmp sle i32 %68, %69
br i1 %70, label %71, label %78
71: ; preds = %67
%72 = load i32, i32* %9
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [4 x i32], [4 x i32]* %20, i64 0, i64 %73
store i32 1, i32* %74
br label %75
75: ; preds = %71
%76 = load i32, i32* %9
%77 = add nsw i32 %76, 1
store i32 %77, i32* %9
br label %67
78: ; preds = %67
store i32 1, i32* %10
br label %79
79: ; preds = %121, %78
%80 = load i32, i32* %10
%81 = icmp sle i32 %80, 2
br i1 %81, label %82, label %124
82: ; preds = %79
store double -1.000000e+00, double* %15
store i32 1, i32* %14
%83 = getelementptr inbounds [76 x double], [76 x double]* %18, i64 0, i64 0
%84 = load double*, double** %5
%85 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 0
%86 = load i32, i32* %7
%87 = load double*, double** %6
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %20, i64 0, i64 0
%89 = load i32, i32* %8
%90 = load i32, i32* %14
%91 = call i32 @mrqmin(double* %83, double* %84, double* %85, i32 %86, double* %87, i32* %88, i32 %89, double* %16, double* %15, i32 %90)
store i32 1, i32* %12
store i32 0, i32* %11
br label %92
92: ; preds = %109, %82
store i32 0, i32* %14
%93 = load i32, i32* %12
%94 = add nsw i32 %93, 1
store i32 %94, i32* %12
%95 = load double, double* %16
store double %95, double* %17
%96 = getelementptr inbounds [76 x double], [76 x double]* %18, i64 0, i64 0
%97 = load double*, double** %5
%98 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 0
%99 = load i32, i32* %7
%100 = load double*, double** %6
%101 = getelementptr inbounds [4 x i32], [4 x i32]* %20, i64 0, i64 0
%102 = load i32, i32* %8
%103 = load i32, i32* %14
%104 = call i32 @mrqmin(double* %96, double* %97, double* %98, i32 %99, double* %100, i32* %101, i32 %102, double* %16, double* %15, i32 %103)
%105 = load i32, i32* %11
%106 = add nsw i32 %105, 1
store i32 %106, i32* %11
%107 = load i32, i32* %11
%108 = icmp slt i32 %107, 4
br i1 %108, label %109, label %110
109: ; preds = %92
br label %92
110: ; preds = %92
store double 0.000000e+00, double* %15
store i32 -1, i32* %14
%111 = getelementptr inbounds [76 x double], [76 x double]* %18, i64 0, i64 0
%112 = load double*, double** %5
%113 = getelementptr inbounds [76 x double], [76 x double]* %19, i64 0, i64 0
%114 = load i32, i32* %7
%115 = load double*, double** %6
%116 = getelementptr inbounds [4 x i32], [4 x i32]* %20, i64 0, i64 0
%117 = load i32, i32* %8
%118 = load i32, i32* %14
%119 = call i32 @mrqmin(double* %111, double* %112, double* %113, i32 %114, double* %115, i32* %116, i32 %117, double* %16, double* %15, i32 %118)
br label %120
120: ; preds = %110
br label %121
121: ; preds = %120
%122 = load i32, i32* %10
%123 = add nsw i32 %122, 1
store i32 %123, i32* %10
br label %79
124: ; preds = %79
ret i32 0
}

LLVM IR (-O2):
define i32 @gaussfit(double* %0, double* %1, i32 %2, i32 %3) {
%5 = alloca double
%6 = alloca double
%7 = alloca [76 x double]
%8 = alloca [76 x double]
%9 = alloca [4 x i32]
%10 = bitcast double* %5 to i8*
%11 = bitcast double* %6 to i8*
%12 = bitcast [76 x double]* %7 to i8*
%13 = bitcast [76 x double]* %8 to i8*
%14 = bitcast [4 x i32]* %9 to i8*
%15 = icmp slt i32 %2, 1
br i1 %15, label %37, label %16
16: ; preds = %4
%17 = add nuw i32 %2, 1
%18 = zext i32 %17 to i64
br label %19
19: ; preds = %16, %33
%20 = phi i64 [ 1, %16 ], [ %35, %33 ]
%21 = trunc i64 %20 to i32
%22 = sitofp i32 %21 to double
%23 = getelementptr inbounds [76 x double], [76 x double]* %7, i64 0, i64 %20
store double %22, double* %23
%24 = getelementptr inbounds double, double* %0, i64 %20
%25 = load double, double* %24
%26 = fmul double %25, 1.000000e-03
%27 = tail call double @sqrt(double %26)
%28 = getelementptr inbounds [76 x double], [76 x double]* %8, i64 0, i64 %20
%29 = fcmp ugt double %27, 0.000000e+00
br i1 %29, label %30, label %33
30: ; preds = %19
%31 = tail call double @sqrt(double %27)
%32 = fdiv double 1.000000e+00, %31
br label %33
33: ; preds = %19, %30
%34 = phi double [ %32, %30 ], [ 3.000000e-01, %19 ]
store double %34, double* %28
%35 = add nuw nsw i64 %20, 1
%36 = icmp eq i64 %35, %18
br i1 %36, label %37, label %19
37: ; preds = %33, %4
%38 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 1
store i32 0, i32* %38
%39 = icmp slt i32 %3, 2
br i1 %39, label %99, label %40
40: ; preds = %37
%41 = add nuw i32 %3, 1
%42 = zext i32 %41 to i64
%43 = add nsw i64 %42, -2
%44 = icmp ult i64 %43, 8
br i1 %44, label %97, label %45
45: ; preds = %40
%46 = and i64 %43, -8
%47 = or i64 %46, 2
%48 = add nsw i64 %46, -8
%49 = lshr exact i64 %48, 3
%50 = add nuw nsw i64 %49, 1
%51 = and i64 %50, 3
%52 = icmp ult i64 %48, 24
br i1 %52, label %81, label %53
53: ; preds = %45
%54 = and i64 %50, 4611686018427387900
br label %55
55: ; preds = %55, %53
%56 = phi i64 [ 0, %53 ], [ %78, %55 ]
%57 = phi i64 [ 0, %53 ], [ %79, %55 ]
%58 = or i64 %56, 2
%59 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %58
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %62
%63 = or i64 %56, 10
%64 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %63
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %67
%68 = or i64 %56, 18
%69 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %72
%73 = or i64 %56, 26
%74 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %73
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %75
%76 = getelementptr inbounds i32, i32* %74, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %77
%78 = add nuw i64 %56, 32
%79 = add i64 %57, 4
%80 = icmp eq i64 %79, %54
br i1 %80, label %81, label %55
81: ; preds = %55, %45
%82 = phi i64 [ 0, %45 ], [ %78, %55 ]
%83 = icmp eq i64 %51, 0
br i1 %83, label %95, label %84
84: ; preds = %81, %84
%85 = phi i64 [ %92, %84 ], [ %82, %81 ]
%86 = phi i64 [ %93, %84 ], [ 0, %81 ]
%87 = or i64 %85, 2
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %87
%89 = bitcast i32* %88 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %89
%90 = getelementptr inbounds i32, i32* %88, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %91
%92 = add nuw i64 %85, 8
%93 = add i64 %86, 1
%94 = icmp eq i64 %93, %51
br i1 %94, label %95, label %84
95: ; preds = %84, %81
%96 = icmp eq i64 %43, %46
br i1 %96, label %99, label %97
97: ; preds = %40, %95
%98 = phi i64 [ 2, %40 ], [ %47, %95 ]
br label %115
99: ; preds = %115, %95, %37
%100 = getelementptr inbounds [76 x double], [76 x double]* %7, i64 0, i64 0
%101 = getelementptr inbounds [76 x double], [76 x double]* %8, i64 0, i64 0
%102 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
store double -1.000000e+00, double* %5
%103 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 1)
%104 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%105 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%106 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%107 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
store double 0.000000e+00, double* %5
%108 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 -1)
store double -1.000000e+00, double* %5
%109 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 1)
%110 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%111 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%112 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
%113 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 0)
store double 0.000000e+00, double* %5
%114 = call i32 @mrqmin(double* %100, double* %0, double* %101, i32 %2, double* %1, i32* %102, i32 %3, double* %6, double* %5, i32 -1)
ret i32 0
115: ; preds = %97, %115
%116 = phi i64 [ %118, %115 ], [ %98, %97 ]
%117 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 %116
store i32 1, i32* %117
%118 = add nuw nsw i64 %116, 1
%119 = icmp eq i64 %118, %42
br i1 %119, label %99, label %115
}