#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 exp(double);
double fabs(double);
double log(double);
double sqrt(double);
void fittinglogt(int n, double x[], double y[], double t, double a[]) {
  int i;
  double ax, ay, dx, dy, u;
  for (i = 0, ax = ay = 0.0; i < n; i++) {
    ax += x[i];
    ay += log(y[i]) / log(t);
  }
  ax /= n;
  ay /= n;
  for (i = 0, dx = dy = 0.0; i < n; i++) {
    u = x[i] - ax;
    dx += u * u;
    dy += u * (log(y[i]) / log(t) - ay);
  }
  a[0] = exp((ay - dy / dx * ax) * log(t));
  a[1] = dy / dx;
  a[2] = a[6] = a[4] = 0.0;
  a[5] = 1.0e+30;
  for (i = 0; i < n; i++) {
    a[3] = a[0] * exp(a[1] * x[i] * log(t));
    u = fabs(y[i] - a[3]);
    a[2] += u * u;
    if (u > a[4])
      a[4] = u;
    if (u < a[5])
      a[5] = u;
    a[6] += u;
  }
  a[3] = sqrt(a[2] / n);
  a[6] /= n;
}


x86 assembly (clang, -O0):
<fittinglogt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11ce <fittinglogt+0x9e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <log@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1166 <fittinglogt+0x36>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ab <fittinglogt+0x17b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <log@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1040 <log@plt>
movsd  -0x70(%rbp),%xmm2
movaps %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm2
subsd  -0x40(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120b <fittinglogt+0xdb>
movsd  -0x40(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0xcb7(%rip),%xmm0
movsd  %xmm0,0x28(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    146e <fittinglogt+0x33e>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
subsd  0x18(%rax),%xmm0
movaps 0xc34(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
ucomisd 0x20(%rax),%xmm0
jbe    1427 <fittinglogt+0x2f7>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movsd  0x28(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    144d <fittinglogt+0x31d>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1355 <fittinglogt+0x225>
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x18(%rax)
cvtsi2sdl -0x4(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movsd  0x30(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fittinglogt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %edi,%r12d
mov    %edi,%r13d
test   %edi,%edi
movsd  %xmm0,0x8(%rsp)
jle    1269 <fittinglogt+0x139>
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,0x10(%rsp)
movsd  (%r14,%rbp,8),%xmm0
movsd  (%r15,%rbp,8),%xmm1
movaps %xmm1,0x20(%rsp)
call   1040 <log@plt>
movaps %xmm0,0x40(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <log@plt>
movapd 0x10(%rsp),%xmm2
movapd 0x40(%rsp),%xmm1
divsd  %xmm0,%xmm1
unpcklpd 0x20(%rsp),%xmm1
addpd  %xmm1,%xmm2
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1170 <fittinglogt+0x40>
movsd  0x8(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movapd %xmm0,0x30(%rsp)
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
test   %r12d,%r12d
jle    128a <fittinglogt+0x15a>
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
movapd %xmm2,0x10(%rsp)
movapd %xmm3,0x20(%rsp)
movsd  (%r14,%rbp,8),%xmm0
movsd  (%r15,%rbp,8),%xmm1
movaps %xmm1,0x40(%rsp)
call   1040 <log@plt>
movaps %xmm0,0x50(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <log@plt>
movapd 0x20(%rsp),%xmm3
movapd 0x10(%rsp),%xmm2
movapd 0x50(%rsp),%xmm1
divsd  %xmm0,%xmm1
unpcklpd 0x40(%rsp),%xmm1
subpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,%r13
jne    11f0 <fittinglogt+0xc0>
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
divsd  %xmm0,%xmm3
movsd  0x8(%rsp),%xmm0
jmp    1296 <fittinglogt+0x166>
cvtsi2sd %r12d,%xmm1
xorpd  %xmm2,%xmm2
movapd %xmm1,0x30(%rsp)
divsd  %xmm1,%xmm2
unpcklpd %xmm2,%xmm2
movsd  0xd78(%rip),%xmm3
jmp    1296 <fittinglogt+0x166>
movsd  0xd6e(%rip),%xmm3
movapd %xmm1,%xmm0
movapd %xmm3,0x20(%rsp)
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm2
movapd %xmm2,0x10(%rsp)
call   1040 <log@plt>
mulsd  0x10(%rsp),%xmm0
call   1030 <exp@plt>
movapd 0x20(%rsp),%xmm1
movapd %xmm0,%xmm2
movsd  %xmm0,(%rbx)
movsd  %xmm1,0x8(%rbx)
movq   $0x0,0x30(%rbx)
movq   $0x0,0x10(%rbx)
xorpd  %xmm0,%xmm0
movhpd 0xd17(%rip),%xmm0
movupd %xmm0,0x20(%rbx)
xorpd  %xmm0,%xmm0
test   %r12d,%r12d
jle    13ac <fittinglogt+0x27c>
add    $0xffffffffffffffff,%r13
xor    %ebp,%ebp
movsd  %xmm2,0x10(%rsp)
nop
mulsd  (%r15,%rbp,8),%xmm1
movapd %xmm1,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <log@plt>
mulsd  0x20(%rsp),%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x18(%rbx)
movsd  (%r14,%rbp,8),%xmm0
subsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
andpd  0xcc9(%rip),%xmm1
mulsd  %xmm0,%xmm0
addsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rbx)
ucomisd 0x20(%rbx),%xmm1
jbe    1371 <fittinglogt+0x241>
movsd  %xmm1,0x20(%rbx)
movsd  0x28(%rbx),%xmm2
ucomisd %xmm1,%xmm2
jbe    1381 <fittinglogt+0x251>
movsd  %xmm1,0x28(%rbx)
movsd  0x30(%rbx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x30(%rbx)
cmp    %rbp,%r13
je     13ac <fittinglogt+0x27c>
movsd  (%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rbx),%xmm1
add    $0x1,%rbp
jmp    1310 <fittinglogt+0x1e0>
divsd  0x30(%rsp),%xmm0
ucomisd 0xc56(%rip),%xmm0
jb     13c2 <fittinglogt+0x292>
sqrtsd %xmm0,%xmm0
jmp    13c7 <fittinglogt+0x297>
call   1050 <sqrt@plt>
movsd  %xmm0,0x18(%rbx)
movsd  0x30(%rbx),%xmm0
divsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rbx)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @fittinglogt(i32 %0, double* %1, double* %2, double %3, double* %4) {
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca double
%10 = alloca double*
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
store i32 %0, i32* %6
store double* %1, double** %7
store double* %2, double** %8
store double %3, double* %9
store double* %4, double** %10
store i32 0, i32* %11
store double 0.000000e+00, double* %13
store double 0.000000e+00, double* %12
br label %17
17: ; preds = %40, %5
%18 = load i32, i32* %11
%19 = load i32, i32* %6
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %43
21: ; preds = %17
%22 = load double*, double** %7
%23 = load i32, i32* %11
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds double, double* %22, i64 %24
%26 = load double, double* %25
%27 = load double, double* %12
%28 = fadd double %27, %26
store double %28, double* %12
%29 = load double*, double** %8
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = call double @log(double %33)
%35 = load double, double* %9
%36 = call double @log(double %35)
%37 = fdiv double %34, %36
%38 = load double, double* %13
%39 = fadd double %38, %37
store double %39, double* %13
br label %40
40: ; preds = %21
%41 = load i32, i32* %11
%42 = add nsw i32 %41, 1
store i32 %42, i32* %11
br label %17
43: ; preds = %17
%44 = load i32, i32* %6
%45 = sitofp i32 %44 to double
%46 = load double, double* %12
%47 = fdiv double %46, %45
store double %47, double* %12
%48 = load i32, i32* %6
%49 = sitofp i32 %48 to double
%50 = load double, double* %13
%51 = fdiv double %50, %49
store double %51, double* %13
store i32 0, i32* %11
store double 0.000000e+00, double* %15
store double 0.000000e+00, double* %14
br label %52
52: ; preds = %82, %43
%53 = load i32, i32* %11
%54 = load i32, i32* %6
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %85
56: ; preds = %52
%57 = load double*, double** %7
%58 = load i32, i32* %11
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load double, double* %12
%63 = fsub double %61, %62
store double %63, double* %16
%64 = load double, double* %16
%65 = load double, double* %16
%66 = load double, double* %14
%67 = call double @llvm.fmuladd.f64(double %64, double %65, double %66)
store double %67, double* %14
%68 = load double, double* %16
%69 = load double*, double** %8
%70 = load i32, i32* %11
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %69, i64 %71
%73 = load double, double* %72
%74 = call double @log(double %73)
%75 = load double, double* %9
%76 = call double @log(double %75)
%77 = fdiv double %74, %76
%78 = load double, double* %13
%79 = fsub double %77, %78
%80 = load double, double* %15
%81 = call double @llvm.fmuladd.f64(double %68, double %79, double %80)
store double %81, double* %15
br label %82
82: ; preds = %56
%83 = load i32, i32* %11
%84 = add nsw i32 %83, 1
store i32 %84, i32* %11
br label %52
85: ; preds = %52
%86 = load double, double* %13
%87 = load double, double* %15
%88 = load double, double* %14
%89 = fdiv double %87, %88
%90 = load double, double* %12
%91 = fneg double %89
%92 = call double @llvm.fmuladd.f64(double %91, double %90, double %86)
%93 = load double, double* %9
%94 = call double @log(double %93)
%95 = fmul double %92, %94
%96 = call double @exp(double %95)
%97 = load double*, double** %10
%98 = getelementptr inbounds double, double* %97, i64 0
store double %96, double* %98
%99 = load double, double* %15
%100 = load double, double* %14
%101 = fdiv double %99, %100
%102 = load double*, double** %10
%103 = getelementptr inbounds double, double* %102, i64 1
store double %101, double* %103
%104 = load double*, double** %10
%105 = getelementptr inbounds double, double* %104, i64 4
store double 0.000000e+00, double* %105
%106 = load double*, double** %10
%107 = getelementptr inbounds double, double* %106, i64 6
store double 0.000000e+00, double* %107
%108 = load double*, double** %10
%109 = getelementptr inbounds double, double* %108, i64 2
store double 0.000000e+00, double* %109
%110 = load double*, double** %10
%111 = getelementptr inbounds double, double* %110, i64 5
store double 1.000000e+30, double* %111
store i32 0, i32* %11
br label %112
112: ; preds = %177, %85
%113 = load i32, i32* %11
%114 = load i32, i32* %6
%115 = icmp slt i32 %113, %114
br i1 %115, label %116, label %180
116: ; preds = %112
%117 = load double*, double** %10
%118 = getelementptr inbounds double, double* %117, i64 0
%119 = load double, double* %118
%120 = load double*, double** %10
%121 = getelementptr inbounds double, double* %120, i64 1
%122 = load double, double* %121
%123 = load double*, double** %7
%124 = load i32, i32* %11
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
%127 = load double, double* %126
%128 = fmul double %122, %127
%129 = load double, double* %9
%130 = call double @log(double %129)
%131 = fmul double %128, %130
%132 = call double @exp(double %131)
%133 = fmul double %119, %132
%134 = load double*, double** %10
%135 = getelementptr inbounds double, double* %134, i64 3
store double %133, double* %135
%136 = load double*, double** %8
%137 = load i32, i32* %11
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = load double*, double** %10
%142 = getelementptr inbounds double, double* %141, i64 3
%143 = load double, double* %142
%144 = fsub double %140, %143
%145 = call double @llvm.fabs.f64(double %144)
store double %145, double* %16
%146 = load double, double* %16
%147 = load double, double* %16
%148 = load double*, double** %10
%149 = getelementptr inbounds double, double* %148, i64 2
%150 = load double, double* %149
%151 = call double @llvm.fmuladd.f64(double %146, double %147, double %150)
store double %151, double* %149
%152 = load double, double* %16
%153 = load double*, double** %10
%154 = getelementptr inbounds double, double* %153, i64 4
%155 = load double, double* %154
%156 = fcmp ogt double %152, %155
br i1 %156, label %157, label %161
157: ; preds = %116
%158 = load double, double* %16
%159 = load double*, double** %10
%160 = getelementptr inbounds double, double* %159, i64 4
store double %158, double* %160
br label %161
161: ; preds = %157, %116
%162 = load double, double* %16
%163 = load double*, double** %10
%164 = getelementptr inbounds double, double* %163, i64 5
%165 = load double, double* %164
%166 = fcmp olt double %162, %165
br i1 %166, label %167, label %171
167: ; preds = %161
%168 = load double, double* %16
%169 = load double*, double** %10
%170 = getelementptr inbounds double, double* %169, i64 5
store double %168, double* %170
br label %171
171: ; preds = %167, %161
%172 = load double, double* %16
%173 = load double*, double** %10
%174 = getelementptr inbounds double, double* %173, i64 6
%175 = load double, double* %174
%176 = fadd double %175, %172
store double %176, double* %174
br label %177
177: ; preds = %171
%178 = load i32, i32* %11
%179 = add nsw i32 %178, 1
store i32 %179, i32* %11
br label %112
180: ; preds = %112
%181 = load double*, double** %10
%182 = getelementptr inbounds double, double* %181, i64 2
%183 = load double, double* %182
%184 = load i32, i32* %6
%185 = sitofp i32 %184 to double
%186 = fdiv double %183, %185
%187 = call double @sqrt(double %186)
%188 = load double*, double** %10
%189 = getelementptr inbounds double, double* %188, i64 3
store double %187, double* %189
%190 = load i32, i32* %6
%191 = sitofp i32 %190 to double
%192 = load double*, double** %10
%193 = getelementptr inbounds double, double* %192, i64 6
%194 = load double, double* %193
%195 = fdiv double %194, %191
store double %195, double* %193
ret void
}

LLVM IR (-O2):
define void @fittinglogt(i32 %0, double* nocapture %1, double* nocapture %2, double %3, double* nocapture %4) {
%6 = icmp sgt i32 %0, 0
br i1 %6, label %12, label %7
7: ; preds = %5
%8 = sitofp i32 %0 to double
%9 = insertelement <2 x double> poison, double %8, i64 0
%10 = fdiv <2 x double> <double 0.000000e+00, double poison>, %9
%11 = shufflevector <2 x double> %10, <2 x double> poison, <2 x i32> zeroinitializer
br label %57
12: ; preds = %5
%13 = zext i32 %0 to i64
br label %14
14: ; preds = %12, %14
%15 = phi i64 [ 0, %12 ], [ %27, %14 ]
%16 = phi <2 x double> [ zeroinitializer, %12 ], [ %26, %14 ]
%17 = getelementptr inbounds double, double* %1, i64 %15
%18 = load double, double* %17
%19 = getelementptr inbounds double, double* %2, i64 %15
%20 = load double, double* %19
%21 = tail call double @log(double %20)
%22 = tail call double @log(double %3)
%23 = fdiv double %21, %22
%24 = insertelement <2 x double> poison, double %23, i64 0
%25 = insertelement <2 x double> %24, double %18, i64 1
%26 = fadd <2 x double> %16, %25
%27 = add nuw nsw i64 %15, 1
%28 = icmp eq i64 %27, %13
br i1 %28, label %29, label %14
29: ; preds = %14
%30 = sitofp i32 %0 to double
%31 = insertelement <2 x double> poison, double %30, i64 0
%32 = shufflevector <2 x double> %31, <2 x double> poison, <2 x i32> zeroinitializer
%33 = fdiv <2 x double> %26, %32
br i1 %6, label %34, label %57
34: ; preds = %29
%35 = zext i32 %0 to i64
br label %36
36: ; preds = %34, %36
%37 = phi i64 [ 0, %34 ], [ %51, %36 ]
%38 = phi <2 x double> [ zeroinitializer, %34 ], [ %50, %36 ]
%39 = getelementptr inbounds double, double* %1, i64 %37
%40 = load double, double* %39
%41 = getelementptr inbounds double, double* %2, i64 %37
%42 = load double, double* %41
%43 = tail call double @log(double %42)
%44 = tail call double @log(double %3)
%45 = fdiv double %43, %44
%46 = insertelement <2 x double> poison, double %45, i64 0
%47 = insertelement <2 x double> %46, double %40, i64 1
%48 = fsub <2 x double> %47, %33
%49 = shufflevector <2 x double> %48, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %49, <2 x double> %48, <2 x double> %38)
%51 = add nuw nsw i64 %37, 1
%52 = icmp eq i64 %51, %35
br i1 %52, label %53, label %36
53: ; preds = %36
%54 = extractelement <2 x double> %50, i64 0
%55 = extractelement <2 x double> %50, i64 1
%56 = fdiv double %54, %55
br label %57
57: ; preds = %7, %53, %29
%58 = phi double [ %30, %53 ], [ %30, %29 ], [ %8, %7 ]
%59 = phi double [ %56, %53 ], [ 0x7FF8000000000000, %29 ], [ 0x7FF8000000000000, %7 ]
%60 = phi <2 x double> [ %33, %53 ], [ %33, %29 ], [ %11, %7 ]
%61 = fneg double %59
%62 = extractelement <2 x double> %60, i64 0
%63 = extractelement <2 x double> %60, i64 1
%64 = tail call double @llvm.fmuladd.f64(double %61, double %63, double %62)
%65 = tail call double @log(double %3)
%66 = fmul double %64, %65
%67 = tail call double @exp(double %66)
store double %67, double* %4
%68 = getelementptr inbounds double, double* %4, i64 1
store double %59, double* %68
%69 = getelementptr inbounds double, double* %4, i64 4
%70 = getelementptr inbounds double, double* %4, i64 6
store double 0.000000e+00, double* %70
%71 = getelementptr inbounds double, double* %4, i64 2
store double 0.000000e+00, double* %71
%72 = getelementptr inbounds double, double* %4, i64 5
%73 = bitcast double* %69 to <2 x double>*
store <2 x double> <double 0.000000e+00, double 1.000000e+30>, <2 x double>* %73
br i1 %6, label %74, label %109
74: ; preds = %57
%75 = getelementptr inbounds double, double* %4, i64 3
%76 = zext i32 %0 to i64
br label %77
77: ; preds = %106, %74
%78 = phi double [ %59, %74 ], [ %108, %106 ]
%79 = phi double [ %67, %74 ], [ %107, %106 ]
%80 = phi i64 [ 0, %74 ], [ %104, %106 ]
%81 = getelementptr inbounds double, double* %1, i64 %80
%82 = load double, double* %81
%83 = fmul double %78, %82
%84 = tail call double @log(double %3)
%85 = fmul double %83, %84
%86 = tail call double @exp(double %85)
%87 = fmul double %79, %86
store double %87, double* %75
%88 = getelementptr inbounds double, double* %2, i64 %80
%89 = load double, double* %88
%90 = fsub double %89, %87
%91 = tail call double @llvm.fabs.f64(double %90)
%92 = load double, double* %71
%93 = tail call double @llvm.fmuladd.f64(double %90, double %90, double %92)
store double %93, double* %71
%94 = load double, double* %69
%95 = fcmp ogt double %91, %94
br i1 %95, label %96, label %97
96: ; preds = %77
store double %91, double* %69
br label %97
97: ; preds = %96, %77
%98 = load double, double* %72
%99 = fcmp olt double %91, %98
br i1 %99, label %100, label %101
100: ; preds = %97
store double %91, double* %72
br label %101
101: ; preds = %100, %97
%102 = load double, double* %70
%103 = fadd double %91, %102
store double %103, double* %70
%104 = add nuw nsw i64 %80, 1
%105 = icmp eq i64 %104, %76
br i1 %105, label %109, label %106
106: ; preds = %101
%107 = load double, double* %4
%108 = load double, double* %68
br label %77
109: ; preds = %101, %57
%110 = phi double [ 0.000000e+00, %57 ], [ %93, %101 ]
%111 = fdiv double %110, %58
%112 = tail call double @sqrt(double %111)
%113 = getelementptr inbounds double, double* %4, i64 3
store double %112, double* %113
%114 = load double, double* %70
%115 = fdiv double %114, %58
store double %115, double* %70
ret void
}