#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);
int stub1(double *, double *, int, int);
int stub2(double *, double *, int, int);
int jacobi_gradient(double x[], double J[],
                    int (*fun)(double x[], double y[], int nx, int ny),
                    double space[], int nx, int ny) {
  int i, j;
  double *x0 = space, *x1 = space + nx, *y0 = x1 + nx, *y1 = y0 + ny,
         eh0 = 1.0e-4, eh;
  for (i = 0; i < nx; i++) {
    for (j = 0; j < nx; j++)
      x0[j] = x1[j] = x[j];
    eh = (x[i] == 0.0) ? eh0 : fabs(x[i]) * eh0;
    x0[i] -= eh;
    x1[i] += eh;
    (*fun)(x0, y0, nx, ny);
    (*fun)(x1, y1, nx, ny);
    for (j = 0; j < ny; j++)
      J[j * nx + i] = (y1[j] - y0[j]) / (eh * 2.0);
  }
  return (0);
}


x86 assembly (clang, -O0):
<jacobi_gradient>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movsd  0xe97(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12f3 <jacobi_gradient+0x1f3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11c9 <jacobi_gradient+0xc9>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1188 <jacobi_gradient+0x88>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f8 <jacobi_gradient+0xf8>
jp     11f8 <jacobi_gradient+0xf8>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    121a <jacobi_gradient+0x11a>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe04(%rip),%xmm1
pand   %xmm1,%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
call   *%rax
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
call   *%rax
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12e0 <jacobi_gradient+0x1e0>
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xd55(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1285 <jacobi_gradient+0x185>
jmp    12e5 <jacobi_gradient+0x1e5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1175 <jacobi_gradient+0x75>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi_gradient>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9d,0x14(%rsp)
mov    %rdx,0x98(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r8d,0x10(%rsp)
test   %r8d,%r8d
jle    157f <jacobi_gradient+0x47f>
mov    %rcx,%rbp
mov    %rdi,%r14
mov    0x10(%rsp),%eax
movslq %eax,%r15
lea    (%rcx,%r15,8),%r12
lea    (%r12,%r15,8),%r9
movslq 0x14(%rsp),%r8
mov    %eax,%r10d
lea    (%r15,%r10,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    0x0(,%r10,8),%r11
add    %rbp,%r11
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x70(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %r11,%r12
setb   %al
cmp    %rbp,%rcx
seta   %dl
lea    (%r14,%r10,8),%rsi
and    %al,%dl
cmp    %rsi,%r12
setb   %al
cmp    %r14,%rcx
seta   %cl
and    %al,%cl
or     %dl,%cl
cmp    %rbp,%rsi
seta   %al
mov    %r9,0x28(%rsp)
lea    (%r9,%r8,8),%rdx
mov    %rdx,0x20(%rsp)
cmp    %r14,%r11
seta   %dl
mov    %r8d,%esi
and    %al,%dl
or     %cl,%dl
mov    %dl,0xf(%rsp)
mov    %rdi,%rax
mov    %rdi,0x60(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x48(%rsp)
mov    %r10d,%edi
and    $0x3,%edi
mov    %rsi,0x78(%rsp)
and    $0xfffffffe,%esi
mov    %rsi,0x40(%rsp)
lea    (%r8,%r15,2),%rax
lea    0x8(,%rax,8),%rax
add    %rbp,%rax
mov    %rax,0x38(%rsp)
mov    %r15,%rax
shl    $0x4,%rax
lea    0x18(%rbp),%rcx
mov    %rcx,0x58(%rsp)
lea    0x18(%r14),%rcx
mov    %rcx,0x50(%rsp)
mov    %rax,0x30(%rsp)
add    %rbp,%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
xor    %r8d,%r8d
mov    0x18(%rsp),%r9
mov    %r10,0x90(%rsp)
mov    %rdi,0x88(%rsp)
mov    0x14(%rsp),%r13d
jmp    1279 <jacobi_gradient+0x179>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    $0x8,%r9
cmp    %r10,%r8
mov    0x88(%rsp),%rdi
je     157f <jacobi_gradient+0x47f>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    %r9,0xa0(%rsp)
je     12a0 <jacobi_gradient+0x1a0>
xor    %eax,%eax
jmp    1350 <jacobi_gradient+0x250>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0x0,0x68(%rsp)
je     156d <jacobi_gradient+0x46d>
mov    0x48(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r12,%rax,8)
movups %xmm1,0x10(%r12,%rax,8)
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm0
movupd 0x30(%r14,%rax,8),%xmm1
movupd %xmm0,0x20(%r12,%rax,8)
movupd %xmm1,0x30(%r12,%rax,8)
movupd %xmm0,0x20(%rbp,%rax,8)
movupd %xmm1,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    12c0 <jacobi_gradient+0x1c0>
testb  $0x1,0x60(%rsp)
je     133f <jacobi_gradient+0x23f>
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd %xmm0,0x0(%rbp,%rax,8)
movupd %xmm1,0x10(%rbp,%rax,8)
mov    0x70(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
je     13ff <jacobi_gradient+0x2ff>
mov    %rax,%rcx
not    %rcx
add    %r10,%rcx
test   %rdi,%rdi
je     138c <jacobi_gradient+0x28c>
mov    %rdi,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1370 <jacobi_gradient+0x270>
cmp    $0x3,%rcx
jb     13ff <jacobi_gradient+0x2ff>
mov    %r10,%rcx
sub    %rax,%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rax),%xmm0
movsd  %xmm0,-0x18(%rdx,%r15,8)
movsd  %xmm0,-0x18(%rdx)
movsd  -0x10(%rax),%xmm0
movsd  %xmm0,-0x10(%rdx,%r15,8)
movsd  %xmm0,-0x10(%rdx)
movsd  -0x8(%rax),%xmm0
movsd  %xmm0,-0x8(%rdx,%r15,8)
movsd  %xmm0,-0x8(%rdx)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rdx,%r15,8)
movsd  %xmm0,(%rdx)
add    $0x20,%rdx
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    13b0 <jacobi_gradient+0x2b0>
movsd  (%r14,%r8,8),%xmm3
movapd %xmm3,%xmm0
andpd  0xbef(%rip),%xmm0
movsd  0xbf7(%rip),%xmm2
mulsd  %xmm2,%xmm0
cmpeqsd 0xbf2(%rip),%xmm3
movapd %xmm3,%xmm1
andnpd %xmm0,%xmm1
andpd  %xmm2,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm3,0xb0(%rsp)
movsd  0x0(%rbp,%r8,8),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%rbp,%r8,8)
movsd  (%r12,%r8,8),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%r8,8)
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%edx
mov    %r13d,%ecx
mov    0x98(%rsp),%rbx
mov    %r8,0xa8(%rsp)
call   *%rbx
mov    %r12,%rdi
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%edx
mov    %r13d,%ecx
call   *%rbx
movapd 0xb0(%rsp),%xmm1
mov    0xa8(%rsp),%r8
mov    0x90(%rsp),%r10
test   %r13d,%r13d
mov    0x80(%rsp),%rbx
mov    0xa0(%rsp),%r9
jle    1260 <jacobi_gradient+0x160>
addsd  %xmm1,%xmm1
cmpl   $0x1,0x14(%rsp)
jne    14e0 <jacobi_gradient+0x3e0>
xor    %eax,%eax
jmp    1534 <jacobi_gradient+0x434>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9,%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdx
mov    0x38(%rsp),%rsi
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rsi,%rax,8),%xmm0
subsd  -0x8(%rbx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx)
movsd  (%rsi,%rax,8),%xmm0
subsd  (%rbx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
add    $0x2,%rax
add    %rdi,%rcx
cmp    %rax,%rdx
jne    1500 <jacobi_gradient+0x400>
testb  $0x1,0x78(%rsp)
je     1260 <jacobi_gradient+0x160>
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x28(%rsp),%rcx
subsd  (%rcx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
imul   %r15,%rax
add    %r8,%rax
mov    0x18(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
jmp    1260 <jacobi_gradient+0x160>
xor    %eax,%eax
testb  $0x1,0x60(%rsp)
jne    1319 <jacobi_gradient+0x219>
jmp    133f <jacobi_gradient+0x23f>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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