#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*/ printf(char *, int, int, int, int);
float get_slope(float *b, int xdim, int ydim, int i0, int i1, int j0, int j1,
                int flag) {
  int i, j, k, inc;
  double sum;
  int nbins;
  double I2, I, F, FI, N;
  double m;
  if ((i0 < 0) || (i1 >= xdim) || (j0 < 0) || (j0 >= ydim)) {
    printf("Unexpected values in get_slope: (%i,%i)-(%i,%i)\n", i0, j0, i1, j1);
    i0 = 0;
    j0 = 0;
    i1 = xdim;
    j1 = ydim;
  }
  I = 0.0;
  I2 = 0.0;
  F = 0.0;
  FI = 0.0;
  if (flag == 0) {
    nbins = (i1 - i0 + 1);
    for (i = i0; i <= i1; i++) {
      sum = 0.0;
      k = (j0 * xdim + i);
      inc = xdim;
      for (j = j0; j <= j1; j++) {
        sum += ((double)b[k]);
        k += inc;
      }
      I += ((double)i);
      I2 += ((double)(i * i));
      F += sum;
      FI += ((double)i) * sum;
    }
  } else {
    nbins = (j1 - j0 + 1);
    for (j = j0; j <= j1; j++) {
      sum = 0.0;
      k = j * xdim + i0;
      inc = 1;
      for (i = i0; i <= i1; i++) {
        sum += ((double)b[k]);
        k += inc;
      }
      I += ((double)j);
      I2 += ((double)(j * j));
      F += sum;
      FI += ((double)j) * sum;
    }
  }
  N = (double)nbins;
  m = ((I * F / N) - FI) / ((I2 / N) - (I * I));
  return ((float)m);
}


x86 assembly (clang, -O0):
<get_slope>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     115f <get_slope+0x4f>
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    115f <get_slope+0x4f>
cmpl   $0x0,-0x1c(%rbp)
jl     115f <get_slope+0x4f>
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1192 <get_slope+0x82>
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%ecx
mov    0x10(%rbp),%r8d
lea    0xe8d(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    129b <get_slope+0x18b>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1296 <get_slope+0x186>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1239 <get_slope+0x129>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11fb <get_slope+0xeb>
cvtsi2sdl -0x20(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cvtsi2sdl -0x20(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ce <get_slope+0xbe>
jmp    137b <get_slope+0x26b>
mov    0x10(%rbp),%eax
sub    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1376 <get_slope+0x266>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1319 <get_slope+0x209>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12db <get_slope+0x1cb>
cvtsi2sdl -0x24(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cvtsi2sdl -0x24(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12ad <get_slope+0x19d>
jmp    137b <get_slope+0x26b>
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
divsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_slope>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r14d
mov    %esi,%ebp
mov    %rdi,%r15
mov    0x58(%rsp),%ebx
mov    0x50(%rsp),%eax
test   %ecx,%ecx
js     12b6 <get_slope+0x1a6>
cmp    %r14d,%r9d
jge    12b6 <get_slope+0x1a6>
cmp    %ebp,%r8d
jge    12b6 <get_slope+0x1a6>
test   %r9d,%r9d
js     12b6 <get_slope+0x1a6>
mov    %eax,%r14d
test   %ebx,%ebx
jne    12dd <get_slope+0x1cd>
mov    %r8d,%eax
sub    %ecx,%eax
jl     12e5 <get_slope+0x1d5>
mov    %eax,(%rsp)
mov    %r9d,%r13d
imul   %ebp,%r13d
add    %ecx,%r13d
movslq %ebp,%rsi
lea    0x1(%r14),%eax
mov    %eax,0x14(%rsp)
mov    %eax,%edi
sub    %r9d,%edi
mov    %r14d,%eax
sub    %r9d,%eax
mov    %eax,0x8(%rsp)
and    $0x3,%edi
mov    %edi,0x4(%rsp)
neg    %edi
mov    %rsi,%rax
shl    $0x4,%rax
lea    0x0(,%rsi,4),%rdx
lea    (%rdx,%rdx,2),%rbp
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
jmp    11fd <get_slope+0xed>
nopl   0x0(%rax,%rax,1)
xorps  %xmm4,%xmm4
cvtsi2sd %ecx,%xmm4
mov    %ecx,%edx
imul   %ecx,%edx
xorps  %xmm5,%xmm5
cvtsi2sd %edx,%xmm5
addsd  %xmm5,%xmm1
movapd %xmm4,%xmm5
unpcklpd %xmm3,%xmm5
addpd  %xmm5,%xmm0
mulsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
lea    0x1(%rcx),%edx
add    $0x1,%r13d
cmp    %r8d,%ecx
mov    %edx,%ecx
je     143c <get_slope+0x32c>
xorpd  %xmm3,%xmm3
cmp    %r9d,%r14d
jl     11c0 <get_slope+0xb0>
movslq %r13d,%rbx
cmpl   $0x0,0x4(%rsp)
je     124b <get_slope+0x13b>
xorpd  %xmm3,%xmm3
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movss  (%r15,%rbx,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm3
add    %rsi,%rbx
add    $0xffffffff,%edx
cmp    %edx,%edi
jne    1220 <get_slope+0x110>
mov    %r9d,%r12d
sub    %edx,%r12d
cmpl   $0x3,0x8(%rsp)
jb     11c0 <get_slope+0xb0>
jmp    125d <get_slope+0x14d>
xorpd  %xmm3,%xmm3
mov    %r9d,%r12d
cmpl   $0x3,0x8(%rsp)
jb     11c0 <get_slope+0xb0>
lea    (%r15,%rbx,4),%r11
add    %rsi,%rbx
lea    (%r15,%rbx,4),%rbx
mov    0x14(%rsp),%r10d
sub    %r12d,%r10d
movss  (%r11),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
movss  (%rbx),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
movss  (%r11,%rsi,8),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
movss  (%r11,%rbp,1),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
add    %rax,%r11
add    %rax,%rbx
add    $0xfffffffc,%r10d
jne    1270 <get_slope+0x160>
jmp    11c0 <get_slope+0xb0>
lea    0xd43(%rip),%rdi
mov    %ecx,%esi
mov    %r9d,%edx
mov    %r8d,%ecx
mov    %eax,%r8d
call   1030 <printf@plt>
xor    %r9d,%r9d
mov    %ebp,%r8d
xor    %ecx,%ecx
test   %ebx,%ebx
je     115c <get_slope+0x4c>
mov    %r14d,%eax
sub    %r9d,%eax
jge    12f6 <get_slope+0x1e6>
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
jmp    143f <get_slope+0x32f>
mov    %eax,(%rsp)
mov    %r9d,%edx
imul   %ebp,%edx
add    %ecx,%edx
lea    0x1(%r8),%r11d
mov    %r11d,0x4(%rsp)
sub    %ecx,%r11d
mov    %r8d,%r13d
sub    %ecx,%r13d
and    $0x3,%r11d
mov    %ecx,%r10d
mov    %r11d,%esi
neg    %esi
lea    0xc(%r15),%rax
mov    %rax,0x8(%rsp)
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
jmp    1380 <get_slope+0x270>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm4,%xmm4
cvtsi2sd %r9d,%xmm4
mov    %r9d,%eax
imul   %r9d,%eax
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
addsd  %xmm5,%xmm1
movapd %xmm4,%xmm5
unpcklpd %xmm3,%xmm5
addpd  %xmm5,%xmm0
mulsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
lea    0x1(%r9),%eax
add    %ebp,%edx
cmp    %r14d,%r9d
mov    %eax,%r9d
je     143c <get_slope+0x32c>
xorpd  %xmm3,%xmm3
cmp    %ecx,%r8d
jl     1340 <get_slope+0x230>
movslq %edx,%rax
test   %r11d,%r11d
je     13cc <get_slope+0x2bc>
lea    (%r15,%rax,4),%rdi
xorpd  %xmm3,%xmm3
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movss  (%rdi),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm3
add    $0xffffffffffffffff,%rbx
add    $0x4,%rdi
cmp    %ebx,%esi
jne    13a0 <get_slope+0x290>
sub    %rbx,%rax
mov    %r10d,%edi
sub    %ebx,%edi
cmp    $0x3,%r13d
jb     1340 <get_slope+0x230>
jmp    13dc <get_slope+0x2cc>
xorpd  %xmm3,%xmm3
mov    %ecx,%edi
cmp    $0x3,%r13d
jb     1340 <get_slope+0x230>
mov    0x8(%rsp),%rbx
lea    (%rbx,%rax,4),%rax
mov    0x4(%rsp),%ebx
sub    %edi,%ebx
xor    %r12d,%r12d
xchg   %ax,%ax
movss  -0xc(%rax,%r12,4),%xmm4
movss  -0x8(%rax,%r12,4),%xmm5
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
addsd  %xmm4,%xmm3
movss  -0x4(%rax,%r12,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
movss  (%rax,%r12,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
add    $0x4,%r12
cmp    %r12d,%ebx
jne    13f0 <get_slope+0x2e0>
jmp    1340 <get_slope+0x230>
mov    (%rsp),%eax
add    $0x1,%eax
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
mulsd  %xmm0,%xmm4
divsd  %xmm3,%xmm4
subsd  %xmm2,%xmm4
divsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm4
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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