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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double sqrt(double);
int fdjac2(int (*func)(void *d, int n, int m, double *p, double *hx, int iflag),
           void *d, int m, int n, double *x, const double *fvec, double *fjac,
           int ldfjac, double epsfcn, double *wa) {
  double h;
  int i, j;
  double eps, temp, epsmch;
  int iflag;
  epsmch = 2.2204460492503131e-16;
  eps = sqrt((((epsfcn) >= (epsmch) ? (epsfcn) : (epsmch))));
  for (j = 0; j < n; ++j) {
    temp = x[j];
    h = eps * fabs(temp);
    if (h == 0.) {
      h = eps;
    }
    x[j] = temp + h;
    iflag = func(d, m, n, x, wa, 2);
    if (iflag < 0) {
      return iflag;
    }
    x[j] = temp;
    for (i = 0; i < m; ++i) {
      fjac[i + j * ldfjac] = (wa[i] - fvec[i]) / h;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<fdjac2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  0xeba(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     116a <fdjac2+0x5a>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1174 <fdjac2+0x64>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12b2 <fdjac2+0x1a2>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movaps 0xe57(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11e8 <fdjac2+0xd8>
jp     11e8 <fdjac2+0xd8>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    $0x2,%r9d
call   *%rax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jge    1235 <fdjac2+0x125>
mov    -0x64(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12b9 <fdjac2+0x1a9>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    129f <fdjac2+0x18f>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    124e <fdjac2+0x13e>
jmp    12a4 <fdjac2+0x194>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    118a <fdjac2+0x7a>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fdjac2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
maxsd  0xed7(%rip),%xmm0
mov    %r9,%rbx
mov    %r8,%r9
mov    %ecx,%r13d
mov    %edx,%r10d
mov    %rsi,0x70(%rsp)
mov    %rdi,0x68(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     114f <fdjac2+0x3f>
sqrtsd %xmm0,%xmm0
jmp    1160 <fdjac2+0x50>
mov    %r9,%r14
mov    %r10d,%ebp
call   1030 <sqrt@plt>
mov    %ebp,%r10d
mov    %r14,%r9
movapd %xmm0,0x80(%rsp)
test   %r13d,%r13d
jle    148c <fdjac2+0x37c>
mov    0x100(%rsp),%r8
mov    0xf0(%rsp),%rax
movslq 0xf8(%rsp),%rcx
mov    %r13d,%edx
mov    %rdx,0x60(%rsp)
mov    %r10d,%esi
lea    (%r8,%rsi,8),%rdx
mov    %rdx,0x30(%rsp)
lea    (%rbx,%rsi,8),%rdx
mov    %rdx,0x28(%rsp)
mov    %esi,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x20(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0x18(%rsp)
mov    %rdx,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %rdi,%rdx
mov    %rdi,0x10(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x8(%rsp)
mov    %rsi,%rdx
neg    %rdx
mov    %rdx,0x38(%rsp)
lea    0x10(%rax),%rdi
mov    %rcx,0x40(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
lea    0x8(%rax),%rbp
xor    %r11d,%r11d
mov    %rsi,0x58(%rsp)
mov    %rbx,0x48(%rsp)
jmp    122a <fdjac2+0x11a>
nopl   0x0(%rax)
add    $0x1,%r11
mov    0x50(%rsp),%rax
add    %rax,%rdi
add    %rax,%rbp
cmp    0x60(%rsp),%r11
je     148c <fdjac2+0x37c>
mov    %rdi,0x78(%rsp)
movsd  (%r9,%r11,8),%xmm4
movapd %xmm4,%xmm0
andpd  0xdcf(%rip),%xmm0
movapd 0x80(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movapd %xmm0,%xmm3
cmpeqsd 0xdad(%rip),%xmm3
movapd %xmm3,%xmm1
andnpd %xmm0,%xmm1
andpd  %xmm2,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm4,0x90(%rsp)
movapd %xmm4,%xmm0
movapd %xmm3,0xa0(%rsp)
addsd  %xmm3,%xmm0
movsd  %xmm0,(%r9,%r11,8)
mov    0x70(%rsp),%rdi
mov    %r10d,%esi
mov    %r13d,%r14d
mov    %r13d,%edx
mov    %r9,%rcx
mov    %r8,%r15
mov    %r9,%r13
mov    $0x2,%r9d
mov    %r10d,%r12d
mov    %r11,%rbx
call   *0x68(%rsp)
test   %eax,%eax
js     148e <fdjac2+0x37e>
movapd 0x90(%rsp),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
test   %r12d,%r12d
mov    %r13,%r9
mov    %r14d,%r13d
mov    %r12d,%r10d
mov    %r15,%r8
mov    0x58(%rsp),%rsi
mov    0x78(%rsp),%rdi
mov    %rbx,%r11
mov    0x48(%rsp),%rbx
movapd 0xa0(%rsp),%xmm3
jle    1210 <fdjac2+0x100>
mov    %r11,%rax
imul   0x40(%rsp),%rax
cmp    $0x1,%r10d
jne    1310 <fdjac2+0x200>
xor    %edx,%edx
jmp    1400 <fdjac2+0x2f0>
mov    %r11,%r12
mov    0xf0(%rsp),%r11
lea    (%r11,%rax,8),%rcx
lea    (%rax,%rsi,1),%rdx
lea    (%r11,%rdx,8),%rdx
cmp    0x30(%rsp),%rcx
setb   %r15b
cmp    %r8,%rdx
seta   %r11b
cmp    0x28(%rsp),%rcx
setb   %cl
cmp    %rbx,%rdx
seta   %r14b
test   %r11b,%r15b
jne    13fa <fdjac2+0x2ea>
mov    $0x0,%edx
and    %r14b,%cl
mov    %r12,%r11
jne    1400 <fdjac2+0x2f0>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0x18(%rsp)
je     147a <fdjac2+0x36a>
mov    0x8(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r8,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rdi,%rcx,8)
movupd 0x10(%r8,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1380 <fdjac2+0x270>
testb  $0x1,0x10(%rsp)
je     13e7 <fdjac2+0x2d7>
movupd (%r8,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
add    %rax,%rcx
mov    0xf0(%rsp),%rdx
movupd %xmm1,(%rdx,%rcx,8)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
je     1210 <fdjac2+0x100>
jmp    1400 <fdjac2+0x2f0>
xor    %edx,%edx
mov    %r12,%r11
nop
mov    %rdx,%rcx
test   $0x1,%sil
je     142f <fdjac2+0x31f>
movsd  (%r8,%rdx,8),%xmm0
subsd  (%rbx,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
add    %rdx,%rax
mov    0xf0(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x38(%rsp),%rdx
je     1210 <fdjac2+0x100>
nopl   (%rax)
movsd  (%r8,%rcx,8),%xmm0
subsd  (%rbx,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%rbp,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
subsd  0x8(%rbx,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1440 <fdjac2+0x330>
jmp    1210 <fdjac2+0x100>
xor    %ecx,%ecx
testb  $0x1,0x10(%rsp)
jne    13c4 <fdjac2+0x2b4>
jmp    13e7 <fdjac2+0x2d7>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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