#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 */
float diff_stat_reg1_reg2(float, float, float, float, float, int *, float *,
                          int, int);
scalar_t__ fabs(double);
int /*<<< orphan*/ printf(char *, ...);
void calculate_split_offset(int *split, float *fl, float *mx_out, float *bx_out,
                            float *my_out, float *by_out, int xmax, int ymax) {
  int jstart;
  float scale, mean1, mean2;
  float tmp1, tmp2;
  float sum0, sum1;
  float mx, bx, my, by;
  float mx_start, bx_start, my_start, by_start;
  float step_b, step_m;
  float eps_b, eps_m;
  float comp_b, comp_m;
  float scale_b, scale_m;
  int i, j, k;
  int u;
  int xmax_ymax;
  int count_down;
  xmax_ymax = xmax * ymax;
  tmp1 = 0.0;
  tmp2 = 0.0;
  mean1 = 0.0;
  mean2 = 0.0;
  for (u = 0; u < xmax_ymax; u++) {
    if (split[u] == 1) {
      mean1 += fl[u];
      tmp1 += 1.0;
    } else if (split[u] == 2) {
      mean2 += fl[u];
      tmp2 += 1.0;
    }
  }
  mean1 /= tmp1;
  mean2 /= tmp2;
  scale = mean1 / mean2;
  jstart = (ymax / 2);
  i = 0;
  j = jstart;
  by = *(by_out);
  bx = *(bx_out);
  mx = *(mx_out);
  my = *(my_out);
  scale_b = 0.5;
  scale_m = 0.5;
  eps_b = scale_b / 2.0;
  eps_m = eps_b / ((float)xmax);
  comp_b = 0.6;
  comp_m = 2.5 / ((float)xmax);
  sum1 = diff_stat_reg1_reg2(mx, bx, my, by, scale, split, fl, xmax, ymax);
  count_down = 100;
  do {
    mx_start = mx;
    bx_start = bx;
    my_start = my;
    by_start = by;
    step_b = 1.0;
    k = 1;
    while (step_b > eps_b) {
      do {
        sum0 = sum1;
        if (k == 0) {
          by += step_b;
        } else {
          by -= step_b;
        }
        sum1 =
            diff_stat_reg1_reg2(mx, bx, my, by, scale, split, fl, xmax, ymax);
      } while (sum1 < sum0);
      k = 1 - k;
      step_b *= scale_b;
    }
    step_b /= scale_b;
    if (k == 0) {
      by += step_b;
    } else {
      by -= step_b;
    }
    sum1 = sum0;
    step_m = 5.0 / ((float)ymax);
    k = 1;
    while (step_m > eps_m) {
      do {
        sum0 = sum1;
        if (k == 0) {
          my += step_m;
        } else {
          my -= step_m;
        }
        sum1 =
            diff_stat_reg1_reg2(mx, bx, my, by, scale, split, fl, xmax, ymax);
      } while (sum1 < sum0);
      k = 1 - k;
      step_m *= scale_m;
    }
    step_m /= scale_m;
    if (k == 0) {
      my += step_m;
    } else {
      my -= step_m;
    }
    sum1 = sum0;
    step_b = 1.0;
    k = 0;
    while (step_b > eps_b) {
      do {
        sum0 = sum1;
        if (k == 0) {
          bx += step_b;
        } else {
          bx -= step_b;
        }
        sum1 =
            diff_stat_reg1_reg2(mx, bx, my, by, scale, split, fl, xmax, ymax);
      } while (sum1 < sum0);
      k = 1 - k;
      step_b *= scale_b;
    }
    step_b /= scale_b;
    if (k == 0) {
      bx += step_b;
    } else {
      bx -= step_b;
    }
    sum1 = sum0;
    step_m = 5.0 / ((float)xmax);
    k = 0;
    while (step_m > eps_m) {
      do {
        sum0 = sum1;
        if (k == 0) {
          mx += step_m;
        } else {
          mx -= step_m;
        }
        sum1 =
            diff_stat_reg1_reg2(mx, bx, my, by, scale, split, fl, xmax, ymax);
      } while (sum1 < sum0);
      k = 1 - k;
      step_m *= scale_m;
    }
    step_m /= scale_m;
    if (k == 0) {
      mx += step_m;
    } else {
      mx -= step_m;
    }
    sum1 = sum0;
    count_down--;
    if (count_down <= 0) {
      printf("Too many tries getting slopes\n");
      printf("Going with what we have.\n");
      break;
    }
  } while ((((float)(fabs((double)(bx - bx_start)))) > comp_b) ||
           (((float)(fabs((double)(by - by_start)))) > comp_b) ||
           (((float)(fabs((double)(mx - mx_start)))) > comp_m) ||
           (((float)(fabs((double)(my - my_start)))) > comp_m));
  printf("offx=(%e)x+(%e)\n", mx, bx);
  printf("offy=(%e)x+(%e)\n", my, by);
  (*mx_out) = mx;
  (*bx_out) = bx;
  (*my_out) = my;
  (*by_out) = by;
  return;
}


x86 assembly (clang, -O0):
<calculate_split_offset>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%eax
imul   0x18(%rbp),%eax
mov    %eax,-0xa4(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    125f <calculate_split_offset+0x12f>
mov    -0x8(%rbp),%rax
movslq -0xa0(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    11f4 <calculate_split_offset+0xc4>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe36(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    1246 <calculate_split_offset+0x116>
mov    -0x8(%rbp),%rax
movslq -0xa0(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jne    1241 <calculate_split_offset+0x111>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde4(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1246 <calculate_split_offset+0x116>
jmp    124b <calculate_split_offset+0x11b>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1190 <calculate_split_offset+0x60>
movss  -0x44(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0xd33(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  0xd23(%rip),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xceb(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtsi2ssl 0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  0xcdb(%rip),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
cvtsi2ssl 0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xca2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x38(%rbp),%xmm4
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  %xmm0,-0x50(%rbp)
movl   $0x64,-0xa8(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xc4f(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x9c(%rbp)
movss  -0x74(%rbp),%xmm0
ucomiss -0x7c(%rbp),%xmm0
jbe    14a6 <calculate_split_offset+0x376>
jmp    13fc <calculate_split_offset+0x2cc>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    1427 <calculate_split_offset+0x2f7>
movss  -0x74(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    143a <calculate_split_offset+0x30a>
movss  -0x74(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x38(%rbp),%xmm4
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     13fc <calculate_split_offset+0x2cc>
mov    $0x1,%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    13e8 <calculate_split_offset+0x2b8>
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x74(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    14dd <calculate_split_offset+0x3ad>
movss  -0x74(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    14f0 <calculate_split_offset+0x3c0>
movss  -0x74(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
cvtsi2ssl 0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb05(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x1,-0x9c(%rbp)
movss  -0x78(%rbp),%xmm0
ucomiss -0x80(%rbp),%xmm0
jbe    15e0 <calculate_split_offset+0x4b0>
jmp    1536 <calculate_split_offset+0x406>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    1561 <calculate_split_offset+0x431>
movss  -0x78(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1574 <calculate_split_offset+0x444>
movss  -0x78(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x38(%rbp),%xmm4
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1536 <calculate_split_offset+0x406>
mov    $0x1,%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1522 <calculate_split_offset+0x3f2>
movss  -0x90(%rbp),%xmm1
ff
movss  -0x78(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    1617 <calculate_split_offset+0x4e7>
movss  -0x78(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    162a <calculate_split_offset+0x4fa>
movss  -0x78(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0x9ec(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x0,-0x9c(%rbp)
movss  -0x74(%rbp),%xmm0
ucomiss -0x7c(%rbp),%xmm0
jbe    1709 <calculate_split_offset+0x5d9>
jmp    165f <calculate_split_offset+0x52f>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    168a <calculate_split_offset+0x55a>
movss  -0x74(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    169d <calculate_split_offset+0x56d>
movss  -0x74(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x38(%rbp),%xmm4
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     165f <calculate_split_offset+0x52f>
mov    $0x1,%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    164b <calculate_split_offset+0x51b>
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x74(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    1740 <calculate_split_offset+0x610>
movss  -0x74(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1753 <calculate_split_offset+0x623>
movss  -0x74(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x8a2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x9c(%rbp)
movss  -0x78(%rbp),%xmm0
ucomiss -0x80(%rbp),%xmm0
jbe    1843 <calculate_split_offset+0x713>
jmp    1799 <calculate_split_offset+0x669>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    17c4 <calculate_split_offset+0x694>
movss  -0x78(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    17d7 <calculate_split_offset+0x6a7>
movss  -0x78(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x38(%rbp),%xmm4
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1799 <calculate_split_offset+0x669>
mov    $0x1,%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1785 <calculate_split_offset+0x655>
movss  -0x90(%rbp),%xmm1
ff
movss  -0x78(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    187a <calculate_split_offset+0x74a>
movss  -0x78(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    188d <calculate_split_offset+0x75d>
movss  -0x78(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa8(%rbp)
cmpl   $0x0,-0xa8(%rbp)
jg     18d4 <calculate_split_offset+0x7a4>
lea    0x772(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x783(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1996 <calculate_split_offset+0x866>
jmp    18d9 <calculate_split_offset+0x7a9>
movss  -0x58(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    $0x1,%al
ucomiss -0x84(%rbp),%xmm0
mov    %al,-0xa9(%rbp)
ja     1988 <calculate_split_offset+0x858>
movss  -0x60(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    $0x1,%al
ucomiss -0x84(%rbp),%xmm0
mov    %al,-0xa9(%rbp)
ja     1988 <calculate_split_offset+0x858>
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    $0x1,%al
ucomiss -0x88(%rbp),%xmm0
mov    %al,-0xa9(%rbp)
ja     1988 <calculate_split_offset+0x858>
movss  -0x5c(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
cvtsi2ss %rax,%xmm0
ucomiss -0x88(%rbp),%xmm0
seta   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    13a9 <calculate_split_offset+0x279>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x6b6(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x6a7(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_split_offset>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    0x118(%rsp),%r14d
mov    0x110(%rsp),%r15d
mov    %r14d,%eax
imul   %r15d,%eax
test   %eax,%eax
jle    11ba <calculate_split_offset+0x7a>
mov    %eax,%r10d
cmp    $0x1,%eax
jne    11c7 <calculate_split_offset+0x87>
xorps  %xmm4,%xmm4
xor    %eax,%eax
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
test   $0x1,%r10b
je     1250 <calculate_split_offset+0x110>
mov    0x0(%rbp,%rax,4),%esi
cmp    $0x1,%esi
je     1243 <calculate_split_offset+0x103>
cmp    $0x2,%esi
jne    1250 <calculate_split_offset+0x110>
addss  (%rbx,%rax,4),%xmm0
addss  0xe4f(%rip),%xmm2
jmp    1250 <calculate_split_offset+0x110>
movss  0xe3e(%rip),%xmm4
jmp    125c <calculate_split_offset+0x11c>
mov    %r10d,%edi
and    $0xfffffffe,%edi
xorps  %xmm4,%xmm4
xor    %eax,%eax
movss  0xe2a(%rip),%xmm3
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
jmp    1203 <calculate_split_offset+0xc3>
cs nopw 0x0(%rax,%rax,1)
nop
addss  0x4(%rbx,%rax,4),%xmm4
addss  %xmm3,%xmm1
add    $0x2,%rax
cmp    %rax,%rdi
je     1188 <calculate_split_offset+0x48>
mov    0x0(%rbp,%rax,4),%esi
cmp    $0x2,%esi
je     1220 <calculate_split_offset+0xe0>
cmp    $0x1,%esi
jne    1229 <calculate_split_offset+0xe9>
addss  (%rbx,%rax,4),%xmm4
addss  %xmm3,%xmm1
jmp    1229 <calculate_split_offset+0xe9>
nopl   0x0(%rax)
addss  (%rbx,%rax,4),%xmm0
addss  %xmm3,%xmm2
mov    0x4(%rbp,%rax,4),%esi
cmp    $0x1,%esi
je     11f0 <calculate_split_offset+0xb0>
cmp    $0x2,%esi
jne    11fa <calculate_split_offset+0xba>
addss  0x4(%rbx,%rax,4),%xmm0
addss  %xmm3,%xmm2
jmp    11fa <calculate_split_offset+0xba>
addss  (%rbx,%rax,4),%xmm4
addss  0xdb4(%rip),%xmm1
divss  %xmm2,%xmm0
divss  %xmm1,%xmm4
divss  %xmm0,%xmm4
mov    %r9,0x88(%rsp)
movss  (%r9),%xmm3
mov    %rcx,0x78(%rsp)
movss  (%rcx),%xmm1
movss  %xmm1,0x14(%rsp)
cvtsi2ss %r15d,%xmm6
movaps %xmm6,0x20(%rsp)
mov    %rdx,0x70(%rsp)
movss  (%rdx),%xmm0
mov    %r8,0x80(%rsp)
movss  (%r8),%xmm2
movss  0xd68(%rip),%xmm5
divss  %xmm6,%xmm5
movss  %xmm5,0x40(%rsp)
movss  %xmm0,0x10(%rsp)
movss  %xmm2,0xc(%rsp)
movss  %xmm3,0x8(%rsp)
movss  %xmm4,0x18(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %r14d,%xmm1
movss  %xmm0,0x50(%rsp)
movss  0xd23(%rip),%xmm0
divss  %xmm1,%xmm0
movaps 0x20(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm2
movaps 0xd23(%rip),%xmm1
divps  %xmm2,%xmm1
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm2,0x60(%rsp)
movss  0xcfc(%rip),%xmm2
movss  %xmm0,0x48(%rsp)
mulss  %xmm0,%xmm2
movss  %xmm2,0x44(%rsp)
movss  0x14(%rsp),%xmm3
movaps %xmm1,0xa0(%rsp)
addss  %xmm1,%xmm1
movaps %xmm1,0x90(%rsp)
mov    $0x64,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x10(%rsp),%xmm7
movss  0xc(%rsp),%xmm2
movss  0x8(%rsp),%xmm1
movss  %xmm1,0x4c(%rsp)
movss  0x18(%rsp),%xmm4
movss  0x50(%rsp),%xmm5
movss  %xmm3,0x14(%rsp)
movss  %xmm2,0x3c(%rsp)
movss  %xmm7,0x1c(%rsp)
cs nopw 0x0(%rax,%rax,1)
movss  %xmm5,0xc(%rsp)
addss  0xc76(%rip),%xmm1
movss  %xmm1,0x8(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0x8(%rsp),%xmm3
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  0x18(%rsp),%xmm4
movss  0x1c(%rsp),%xmm7
movss  0x3c(%rsp),%xmm2
movss  0x14(%rsp),%xmm3
movss  0x8(%rsp),%xmm1
movaps %xmm0,%xmm5
movss  0xc(%rsp),%xmm0
ucomiss %xmm5,%xmm0
ja     1390 <calculate_split_offset+0x250>
nopl   (%rax)
movss  %xmm5,0xc(%rsp)
addss  0xc1a(%rip),%xmm1
movss  %xmm1,0x8(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0x8(%rsp),%xmm3
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  0x18(%rsp),%xmm4
movss  0xc(%rsp),%xmm6
movss  0x1c(%rsp),%xmm7
movss  0x3c(%rsp),%xmm2
movss  0x14(%rsp),%xmm3
movss  0x8(%rsp),%xmm1
movaps %xmm0,%xmm5
ucomiss %xmm0,%xmm6
ja     13f0 <calculate_split_offset+0x2b0>
movss  0x48(%rsp),%xmm0
ucomiss 0x60(%rsp),%xmm0
addss  0xbbc(%rip),%xmm1
movss  %xmm1,0x8(%rsp)
jbe    1540 <calculate_split_offset+0x400>
mov    $0x1,%eax
movaps %xmm2,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%r13d
movaps %xmm0,%xmm2
test   %eax,%eax
je     1494 <calculate_split_offset+0x354>
movaps %xmm0,%xmm2
xorps  0xb9c(%rip),%xmm2
movaps %xmm0,0x20(%rsp)
movaps %xmm2,0x50(%rsp)
xchg   %ax,%ax
movss  %xmm6,0x10(%rsp)
addss  %xmm2,%xmm1
movss  %xmm1,0xc(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0xc(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
movss  0x18(%rsp),%xmm4
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movaps 0x50(%rsp),%xmm2
movss  0x10(%rsp),%xmm5
movss  0x1c(%rsp),%xmm7
movss  0x14(%rsp),%xmm3
movss  0xc(%rsp),%xmm1
movaps %xmm0,%xmm6
ucomiss %xmm0,%xmm5
ja     14a0 <calculate_split_offset+0x360>
mov    $0x1,%eax
sub    %r13d,%eax
movaps 0x20(%rsp),%xmm0
mulss  0xb05(%rip),%xmm0
ucomiss 0x60(%rsp),%xmm0
ja     1480 <calculate_split_offset+0x340>
addss  %xmm0,%xmm0
cmp    $0x1,%r13d
je     154c <calculate_split_offset+0x40c>
xorps  0xb01(%rip),%xmm0
jmp    154c <calculate_split_offset+0x40c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm6,%xmm5
movaps %xmm2,%xmm1
movss  0x44(%rsp),%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
cs nopw 0x0(%rax,%rax,1)
movss  %xmm5,0x10(%rsp)
addss  0xa96(%rip),%xmm3
movss  %xmm3,0x20(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0xc(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
movss  0x18(%rsp),%xmm4
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  0x20(%rsp),%xmm3
movss  0x1c(%rsp),%xmm7
movaps %xmm0,%xmm5
movss  0x10(%rsp),%xmm0
ucomiss %xmm5,%xmm0
ja     1560 <calculate_split_offset+0x420>
nopw   0x0(%rax,%rax,1)
movss  %xmm5,0x10(%rsp)
addss  0xa4e(%rip),%xmm3
movss  %xmm3,0x20(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0xc(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
movss  0x18(%rsp),%xmm4
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movss  0x10(%rsp),%xmm1
movss  0x20(%rsp),%xmm3
movss  0x1c(%rsp),%xmm7
movaps %xmm0,%xmm5
ucomiss %xmm0,%xmm1
ja     15c0 <calculate_split_offset+0x480>
movaps 0xa0(%rsp),%xmm0
ucomiss 0x60(%rsp),%xmm0
addss  0x9ec(%rip),%xmm3
movss  %xmm3,0x20(%rsp)
jbe    1710 <calculate_split_offset+0x5d0>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %eax,%r13d
movaps %xmm0,%xmm5
test   %eax,%eax
je     1654 <calculate_split_offset+0x514>
movaps %xmm0,%xmm5
xorps  0x9dc(%rip),%xmm5
movaps %xmm0,0xb0(%rsp)
movaps %xmm5,0xc0(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm1,0x50(%rsp)
addss  %xmm5,%xmm7
movss  %xmm7,0x10(%rsp)
movaps %xmm7,%xmm0
movaps %xmm3,%xmm1
movss  0xc(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
movss  0x18(%rsp),%xmm4
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1030 <diff_stat_reg1_reg2@plt>
movaps 0xc0(%rsp),%xmm5
movss  0x50(%rsp),%xmm2
movss  0x10(%rsp),%xmm7
movss  0x20(%rsp),%xmm3
movaps %xmm0,%xmm1
ucomiss %xmm0,%xmm2
ja     1670 <calculate_split_offset+0x530>
mov    $0x1,%eax
sub    %r13d,%eax
movaps 0xb0(%rsp),%xmm0
mulss  0x935(%rip),%xmm0
ucomiss 0x60(%rsp),%xmm0
ja     1640 <calculate_split_offset+0x500>
addss  %xmm0,%xmm0
cmp    $0x1,%r13d
je     171b <calculate_split_offset+0x5db>
xorps  0x931(%rip),%xmm0
jmp    171b <calculate_split_offset+0x5db>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps 0x90(%rsp),%xmm0
movaps %xmm1,%xmm2
movss  0x14(%rsp),%xmm1
addss  %xmm0,%xmm7
cmp    $0x1,%r12d
movss  %xmm7,0x10(%rsp)
jbe    17e3 <calculate_split_offset+0x6a3>
movss  %xmm2,0x50(%rsp)
add    $0xffffffff,%r12d
subss  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
call   1060 <fabs@plt>
movss  0x20(%rsp),%xmm3
test   %rax,%rax
jg     1350 <calculate_split_offset+0x210>
movss  0x8(%rsp),%xmm0
subss  0x4c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <fabs@plt>
movss  0x20(%rsp),%xmm3
test   %rax,%rax
jg     1350 <calculate_split_offset+0x210>
movss  0x10(%rsp),%xmm0
subss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
ucomiss 0x40(%rsp),%xmm0
movss  0x20(%rsp),%xmm3
ja     1350 <calculate_split_offset+0x210>
movss  0xc(%rsp),%xmm0
subss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <fabs@plt>
movss  0x20(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
ucomiss 0x40(%rsp),%xmm0
movaps %xmm1,%xmm3
ja     1350 <calculate_split_offset+0x210>
jmp    1801 <calculate_split_offset+0x6c1>
lea    0x878(%rip),%rdi
call   1040 <puts@plt>
lea    0x88a(%rip),%rdi
call   1040 <puts@plt>
movss  0x20(%rsp),%xmm1
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0x82a(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x819(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    0x70(%rsp),%rax
movss  0x10(%rsp),%xmm0
movss  %xmm0,(%rax)
mov    0x78(%rsp),%rax
movss  0x20(%rsp),%xmm0
movss  %xmm0,(%rax)
mov    0x80(%rsp),%rax
movss  0xc(%rsp),%xmm0
movss  %xmm0,(%rax)
mov    0x88(%rsp),%rax
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rax)
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [31 x i8] c"Too many tries getting slopes\0A\00"
@.str.1 = [26 x i8] c"Going with what we have.\0A\00"
@.str.2 = [17 x i8] c"offx=(%e)x+(%e)\0A\00"
@.str.3 = [17 x i8] c"offy=(%e)x+(%e)\0A\00"
define void @calculate_split_offset(i32* %0, float* %1, float* %2, float* %3, float* %4, float* %5, i32 %6, i32 %7) {
%9 = alloca i32*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
store i32* %0, i32** %9
store float* %1, float** %10
store float* %2, float** %11
store float* %3, float** %12
store float* %4, float** %13
store float* %5, float** %14
store i32 %6, i32* %15
store i32 %7, i32* %16
%47 = load i32, i32* %15
%48 = load i32, i32* %16
%49 = mul nsw i32 %47, %48
store i32 %49, i32* %45
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store i32 0, i32* %44
br label %50
50: ; preds = %94, %8
%51 = load i32, i32* %44
%52 = load i32, i32* %45
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %97
54: ; preds = %50
%55 = load i32*, i32** %9
%56 = load i32, i32* %44
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
%59 = load i32, i32* %58
%60 = icmp eq i32 %59, 1
br i1 %60, label %61, label %73
61: ; preds = %54
%62 = load float*, float** %10
%63 = load i32, i32* %44
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = load float, float* %19
%68 = fadd float %67, %66
store float %68, float* %19
%69 = load float, float* %21
%70 = fpext float %69 to double
%71 = fadd double %70, 1.000000e+00
%72 = fptrunc double %71 to float
store float %72, float* %21
br label %93
73: ; preds = %54
%74 = load i32*, i32** %9
%75 = load i32, i32* %44
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %74, i64 %76
%78 = load i32, i32* %77
%79 = icmp eq i32 %78, 2
br i1 %79, label %80, label %92
80: ; preds = %73
%81 = load float*, float** %10
%82 = load i32, i32* %44
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %81, i64 %83
%85 = load float, float* %84
%86 = load float, float* %20
%87 = fadd float %86, %85
store float %87, float* %20
%88 = load float, float* %22
%89 = fpext float %88 to double
%90 = fadd double %89, 1.000000e+00
%91 = fptrunc double %90 to float
store float %91, float* %22
br label %92
92: ; preds = %80, %73
br label %93
93: ; preds = %92, %61
br label %94
94: ; preds = %93
%95 = load i32, i32* %44
%96 = add nsw i32 %95, 1
store i32 %96, i32* %44
br label %50
97: ; preds = %50
%98 = load float, float* %21
%99 = load float, float* %19
%100 = fdiv float %99, %98
store float %100, float* %19
%101 = load float, float* %22
%102 = load float, float* %20
%103 = fdiv float %102, %101
store float %103, float* %20
%104 = load float, float* %19
%105 = load float, float* %20
%106 = fdiv float %104, %105
store float %106, float* %18
%107 = load i32, i32* %16
%108 = sdiv i32 %107, 2
store i32 %108, i32* %17
store i32 0, i32* %41
%109 = load i32, i32* %17
store i32 %109, i32* %42
%110 = load float*, float** %14
%111 = load float, float* %110
store float %111, float* %28
%112 = load float*, float** %12
%113 = load float, float* %112
store float %113, float* %26
%114 = load float*, float** %11
%115 = load float, float* %114
store float %115, float* %25
%116 = load float*, float** %13
%117 = load float, float* %116
store float %117, float* %27
store float 5.000000e-01, float* %39
store float 5.000000e-01, float* %40
%118 = load float, float* %39
%119 = fpext float %118 to double
%120 = fdiv double %119, 2.000000e+00
%121 = fptrunc double %120 to float
store float %121, float* %35
%122 = load float, float* %35
%123 = load i32, i32* %15
%124 = sitofp i32 %123 to float
%125 = fdiv float %122, %124
store float %125, float* %36
store float 0x3FE3333340000000, float* %37
%126 = load i32, i32* %15
%127 = sitofp i32 %126 to float
%128 = fpext float %127 to double
%129 = fdiv double 2.500000e+00, %128
%130 = fptrunc double %129 to float
store float %130, float* %38
%131 = load float, float* %25
%132 = load float, float* %26
%133 = load float, float* %27
%134 = load float, float* %28
%135 = load float, float* %18
%136 = load i32*, i32** %9
%137 = load float*, float** %10
%138 = load i32, i32* %15
%139 = load i32, i32* %16
%140 = call float @diff_stat_reg1_reg2(float %131, float %132, float %133, float %134, float %135, i32* %136, float* %137, i32 %138, i32 %139)
store float %140, float* %24
store i32 100, i32* %46
br label %141
141: ; preds = %416, %97
%142 = load float, float* %25
store float %142, float* %29
%143 = load float, float* %26
store float %143, float* %30
%144 = load float, float* %27
store float %144, float* %31
%145 = load float, float* %28
store float %145, float* %32
store float 1.000000e+00, float* %33
store i32 1, i32* %43
br label %146
146: ; preds = %178, %141
%147 = load float, float* %33
%148 = load float, float* %35
%149 = fcmp ogt float %147, %148
br i1 %149, label %150, label %184
150: ; preds = %146
br label %151
151: ; preds = %174, %150
%152 = load float, float* %24
store float %152, float* %23
%153 = load i32, i32* %43
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %159
155: ; preds = %151
%156 = load float, float* %33
%157 = load float, float* %28
%158 = fadd float %157, %156
store float %158, float* %28
br label %163
159: ; preds = %151
%160 = load float, float* %33
%161 = load float, float* %28
%162 = fsub float %161, %160
store float %162, float* %28
br label %163
163: ; preds = %159, %155
%164 = load float, float* %25
%165 = load float, float* %26
%166 = load float, float* %27
%167 = load float, float* %28
%168 = load float, float* %18
%169 = load i32*, i32** %9
%170 = load float*, float** %10
%171 = load i32, i32* %15
%172 = load i32, i32* %16
%173 = call float @diff_stat_reg1_reg2(float %164, float %165, float %166, float %167, float %168, i32* %169, float* %170, i32 %171, i32 %172)
store float %173, float* %24
br label %174
174: ; preds = %163
%175 = load float, float* %24
%176 = load float, float* %23
%177 = fcmp olt float %175, %176
br i1 %177, label %151, label %178
178: ; preds = %174
%179 = load i32, i32* %43
%180 = sub nsw i32 1, %179
store i32 %180, i32* %43
%181 = load float, float* %39
%182 = load float, float* %33
%183 = fmul float %182, %181
store float %183, float* %33
br label %146
184: ; preds = %146
%185 = load float, float* %39
%186 = load float, float* %33
%187 = fdiv float %186, %185
store float %187, float* %33
%188 = load i32, i32* %43
%189 = icmp eq i32 %188, 0
br i1 %189, label %190, label %194
190: ; preds = %184
%191 = load float, float* %33
%192 = load float, float* %28
%193 = fadd float %192, %191
store float %193, float* %28
br label %198
194: ; preds = %184
%195 = load float, float* %33
%196 = load float, float* %28
%197 = fsub float %196, %195
store float %197, float* %28
br label %198
198: ; preds = %194, %190
%199 = load float, float* %23
store float %199, float* %24
%200 = load i32, i32* %16
%201 = sitofp i32 %200 to float
%202 = fpext float %201 to double
%203 = fdiv double 5.000000e+00, %202
%204 = fptrunc double %203 to float
store float %204, float* %34
store i32 1, i32* %43
br label %205
205: ; preds = %237, %198
%206 = load float, float* %34
%207 = load float, float* %36
%208 = fcmp ogt float %206, %207
br i1 %208, label %209, label %243
209: ; preds = %205
br label %210
210: ; preds = %233, %209
%211 = load float, float* %24
store float %211, float* %23
%212 = load i32, i32* %43
%213 = icmp eq i32 %212, 0
br i1 %213, label %214, label %218
214: ; preds = %210
%215 = load float, float* %34
%216 = load float, float* %27
%217 = fadd float %216, %215
store float %217, float* %27
br label %222
218: ; preds = %210
%219 = load float, float* %34
%220 = load float, float* %27
%221 = fsub float %220, %219
store float %221, float* %27
br label %222
222: ; preds = %218, %214
%223 = load float, float* %25
%224 = load float, float* %26
%225 = load float, float* %27
%226 = load float, float* %28
%227 = load float, float* %18
%228 = load i32*, i32** %9
%229 = load float*, float** %10
%230 = load i32, i32* %15
%231 = load i32, i32* %16
%232 = call float @diff_stat_reg1_reg2(float %223, float %224, float %225, float %226, float %227, i32* %228, float* %229, i32 %230, i32 %231)
store float %232, float* %24
br label %233
233: ; preds = %222
%234 = load float, float* %24
%235 = load float, float* %23
%236 = fcmp olt float %234, %235
br i1 %236, label %210, label %237
237: ; preds = %233
%238 = load i32, i32* %43
%239 = sub nsw i32 1, %238
store i32 %239, i32* %43
%240 = load float, float* %40
%241 = load float, float* %34
%242 = fmul float %241, %240
store float %242, float* %34
br label %205
243: ; preds = %205
%244 = load float, float* %40
%245 = load float, float* %34
%246 = fdiv float %245, %244
store float %246, float* %34
%247 = load i32, i32* %43
%248 = icmp eq i32 %247, 0
br i1 %248, label %249, label %253
249: ; preds = %243
%250 = load float, float* %34
%251 = load float, float* %27
%252 = fadd float %251, %250
store float %252, float* %27
br label %257
253: ; preds = %243
%254 = load float, float* %34
%255 = load float, float* %27
%256 = fsub float %255, %254
store float %256, float* %27
br label %257
257: ; preds = %253, %249
%258 = load float, float* %23
store float %258, float* %24
store float 1.000000e+00, float* %33
store i32 0, i32* %43
br label %259
259: ; preds = %291, %257
%260 = load float, float* %33
%261 = load float, float* %35
%262 = fcmp ogt float %260, %261
br i1 %262, label %263, label %297
263: ; preds = %259
br label %264
264: ; preds = %287, %263
%265 = load float, float* %24
store float %265, float* %23
%266 = load i32, i32* %43
%267 = icmp eq i32 %266, 0
br i1 %267, label %268, label %272
268: ; preds = %264
%269 = load float, float* %33
%270 = load float, float* %26
%271 = fadd float %270, %269
store float %271, float* %26
br label %276
272: ; preds = %264
%273 = load float, float* %33
%274 = load float, float* %26
%275 = fsub float %274, %273
store float %275, float* %26
br label %276
276: ; preds = %272, %268
%277 = load float, float* %25
%278 = load float, float* %26
%279 = load float, float* %27
%280 = load float, float* %28
%281 = load float, float* %18
%282 = load i32*, i32** %9
%283 = load float*, float** %10
%284 = load i32, i32* %15
%285 = load i32, i32* %16
%286 = call float @diff_stat_reg1_reg2(float %277, float %278, float %279, float %280, float %281, i32* %282, float* %283, i32 %284, i32 %285)
store float %286, float* %24
br label %287
287: ; preds = %276
%288 = load float, float* %24
%289 = load float, float* %23
%290 = fcmp olt float %288, %289
br i1 %290, label %264, label %291
291: ; preds = %287
%292 = load i32, i32* %43
%293 = sub nsw i32 1, %292
store i32 %293, i32* %43
%294 = load float, float* %39
%295 = load float, float* %33
%296 = fmul float %295, %294
store float %296, float* %33
br label %259
297: ; preds = %259
%298 = load float, float* %39
%299 = load float, float* %33
%300 = fdiv float %299, %298
store float %300, float* %33
%301 = load i32, i32* %43
%302 = icmp eq i32 %301, 0
br i1 %302, label %303, label %307
303: ; preds = %297
%304 = load float, float* %33
%305 = load float, float* %26
%306 = fadd float %305, %304
store float %306, float* %26
br label %311
307: ; preds = %297
%308 = load float, float* %33
%309 = load float, float* %26
%310 = fsub float %309, %308
store float %310, float* %26
br label %311
311: ; preds = %307, %303
%312 = load float, float* %23
store float %312, float* %24
%313 = load i32, i32* %15
%314 = sitofp i32 %313 to float
%315 = fpext float %314 to double
%316 = fdiv double 5.000000e+00, %315
%317 = fptrunc double %316 to float
store float %317, float* %34
store i32 0, i32* %43
br label %318
318: ; preds = %350, %311
%319 = load float, float* %34
%320 = load float, float* %36
%321 = fcmp ogt float %319, %320
br i1 %321, label %322, label %356
322: ; preds = %318
br label %323
323: ; preds = %346, %322
%324 = load float, float* %24
store float %324, float* %23
%325 = load i32, i32* %43
%326 = icmp eq i32 %325, 0
br i1 %326, label %327, label %331
327: ; preds = %323
%328 = load float, float* %34
%329 = load float, float* %25
%330 = fadd float %329, %328
store float %330, float* %25
br label %335
331: ; preds = %323
%332 = load float, float* %34
%333 = load float, float* %25
%334 = fsub float %333, %332
store float %334, float* %25
br label %335
335: ; preds = %331, %327
%336 = load float, float* %25
%337 = load float, float* %26
%338 = load float, float* %27
%339 = load float, float* %28
%340 = load float, float* %18
%341 = load i32*, i32** %9
%342 = load float*, float** %10
%343 = load i32, i32* %15
%344 = load i32, i32* %16
%345 = call float @diff_stat_reg1_reg2(float %336, float %337, float %338, float %339, float %340, i32* %341, float* %342, i32 %343, i32 %344)
store float %345, float* %24
br label %346
346: ; preds = %335
%347 = load float, float* %24
%348 = load float, float* %23
%349 = fcmp olt float %347, %348
br i1 %349, label %323, label %350
350: ; preds = %346
%351 = load i32, i32* %43
%352 = sub nsw i32 1, %351
store i32 %352, i32* %43
%353 = load float, float* %40
%354 = load float, float* %34
%355 = fmul float %354, %353
store float %355, float* %34
br label %318
356: ; preds = %318
%357 = load float, float* %40
%358 = load float, float* %34
%359 = fdiv float %358, %357
store float %359, float* %34
%360 = load i32, i32* %43
%361 = icmp eq i32 %360, 0
br i1 %361, label %362, label %366
362: ; preds = %356
%363 = load float, float* %34
%364 = load float, float* %25
%365 = fadd float %364, %363
store float %365, float* %25
br label %370
366: ; preds = %356
%367 = load float, float* %34
%368 = load float, float* %25
%369 = fsub float %368, %367
store float %369, float* %25
br label %370
370: ; preds = %366, %362
%371 = load float, float* %23
store float %371, float* %24
%372 = load i32, i32* %46
%373 = add nsw i32 %372, -1
store i32 %373, i32* %46
%374 = load i32, i32* %46
%375 = icmp sle i32 %374, 0
br i1 %375, label %376, label %379
376: ; preds = %370
%377 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
%378 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %418
379: ; preds = %370
br label %380
380: ; preds = %379
%381 = load float, float* %26
%382 = load float, float* %30
%383 = fsub float %381, %382
%384 = fpext float %383 to double
%385 = call i64 @fabs(double %384)
%386 = sitofp i64 %385 to float
%387 = load float, float* %37
%388 = fcmp ogt float %386, %387
br i1 %388, label %416, label %389
389: ; preds = %380
%390 = load float, float* %28
%391 = load float, float* %32
%392 = fsub float %390, %391
%393 = fpext float %392 to double
%394 = call i64 @fabs(double %393)
%395 = sitofp i64 %394 to float
%396 = load float, float* %37
%397 = fcmp ogt float %395, %396
br i1 %397, label %416, label %398
398: ; preds = %389
%399 = load float, float* %25
%400 = load float, float* %29
%401 = fsub float %399, %400
%402 = fpext float %401 to double
%403 = call i64 @fabs(double %402)
%404 = sitofp i64 %403 to float
%405 = load float, float* %38
%406 = fcmp ogt float %404, %405
br i1 %406, label %416, label %407
407: ; preds = %398
%408 = load float, float* %27
%409 = load float, float* %31
%410 = fsub float %408, %409
%411 = fpext float %410 to double
%412 = call i64 @fabs(double %411)
%413 = sitofp i64 %412 to float
%414 = load float, float* %38
%415 = fcmp ogt float %413, %414
br label %416
416: ; preds = %407, %398, %389, %380
%417 = phi i1 [ true, %398 ], [ true, %389 ], [ true, %380 ], [ %415, %407 ]
br i1 %417, label %141, label %418
418: ; preds = %416, %376
%419 = load float, float* %25
%420 = fpext float %419 to double
%421 = load float, float* %26
%422 = fpext float %421 to double
%423 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), double %420, double %422)
%424 = load float, float* %27
%425 = fpext float %424 to double
%426 = load float, float* %28
%427 = fpext float %426 to double
%428 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), double %425, double %427)
%429 = load float, float* %25
%430 = load float*, float** %11
store float %429, float* %430
%431 = load float, float* %26
%432 = load float*, float** %12
store float %431, float* %432
%433 = load float, float* %27
%434 = load float*, float** %13
store float %433, float* %434
%435 = load float, float* %28
%436 = load float*, float** %14
store float %435, float* %436
ret void
}

LLVM IR (-O2):
@.str.2 = [17 x i8] c"offx=(%e)x+(%e)\0A\00"
@.str.3 = [17 x i8] c"offy=(%e)x+(%e)\0A\00"
@str = [30 x i8] c"Too many tries getting slopes\00"
@str.4 = [25 x i8] c"Going with what we have.\00"
define void @calculate_split_offset(i32* %0, float* %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, i32 %6, i32 %7) {
%9 = mul i32 %7, %6
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %94
11: ; preds = %8
%12 = zext i32 %9 to i64
%13 = and i64 %12, 1
%14 = icmp eq i32 %9, 1
br i1 %14, label %62, label %15
15: ; preds = %11
%16 = and i64 %12, 4294967294
br label %17
17: ; preds = %54, %15
%18 = phi i64 [ 0, %15 ], [ %59, %54 ]
%19 = phi float [ 0.000000e+00, %15 ], [ %58, %54 ]
%20 = phi float [ 0.000000e+00, %15 ], [ %57, %54 ]
%21 = phi float [ 0.000000e+00, %15 ], [ %56, %54 ]
%22 = phi float [ 0.000000e+00, %15 ], [ %55, %54 ]
%23 = phi i64 [ 0, %15 ], [ %60, %54 ]
%24 = getelementptr inbounds i32, i32* %0, i64 %18
%25 = load i32, i32* %24
switch i32 %25, label %36 [
i32 1, label %26
i32 2, label %31
]
26: ; preds = %17
%27 = getelementptr inbounds float, float* %1, i64 %18
%28 = load float, float* %27
%29 = fadd float %19, %28
%30 = fadd float %21, 1.000000e+00
br label %36
31: ; preds = %17
%32 = getelementptr inbounds float, float* %1, i64 %18
%33 = load float, float* %32
%34 = fadd float %20, %33
%35 = fadd float %22, 1.000000e+00
br label %36
36: ; preds = %17, %26, %31
%37 = phi float [ %22, %26 ], [ %35, %31 ], [ %22, %17 ]
%38 = phi float [ %30, %26 ], [ %21, %31 ], [ %21, %17 ]
%39 = phi float [ %20, %26 ], [ %34, %31 ], [ %20, %17 ]
%40 = phi float [ %29, %26 ], [ %19, %31 ], [ %19, %17 ]
%41 = or i64 %18, 1
%42 = getelementptr inbounds i32, i32* %0, i64 %41
%43 = load i32, i32* %42
switch i32 %43, label %54 [
i32 1, label %49
i32 2, label %44
]
44: ; preds = %36
%45 = getelementptr inbounds float, float* %1, i64 %41
%46 = load float, float* %45
%47 = fadd float %39, %46
%48 = fadd float %37, 1.000000e+00
br label %54
49: ; preds = %36
%50 = getelementptr inbounds float, float* %1, i64 %41
%51 = load float, float* %50
%52 = fadd float %40, %51
%53 = fadd float %38, 1.000000e+00
br label %54
54: ; preds = %49, %44, %36
%55 = phi float [ %37, %49 ], [ %48, %44 ], [ %37, %36 ]
%56 = phi float [ %53, %49 ], [ %38, %44 ], [ %38, %36 ]
%57 = phi float [ %39, %49 ], [ %47, %44 ], [ %39, %36 ]
%58 = phi float [ %52, %49 ], [ %40, %44 ], [ %40, %36 ]
%59 = add nuw nsw i64 %18, 2
%60 = add i64 %23, 2
%61 = icmp eq i64 %60, %16
br i1 %61, label %62, label %17
62: ; preds = %54, %11
%63 = phi float [ undef, %11 ], [ %55, %54 ]
%64 = phi float [ undef, %11 ], [ %56, %54 ]
%65 = phi float [ undef, %11 ], [ %57, %54 ]
%66 = phi float [ undef, %11 ], [ %58, %54 ]
%67 = phi i64 [ 0, %11 ], [ %59, %54 ]
%68 = phi float [ 0.000000e+00, %11 ], [ %58, %54 ]
%69 = phi float [ 0.000000e+00, %11 ], [ %57, %54 ]
%70 = phi float [ 0.000000e+00, %11 ], [ %56, %54 ]
%71 = phi float [ 0.000000e+00, %11 ], [ %55, %54 ]
%72 = icmp eq i64 %13, 0
br i1 %72, label %86, label %73
73: ; preds = %62
%74 = getelementptr inbounds i32, i32* %0, i64 %67
%75 = load i32, i32* %74
switch i32 %75, label %86 [
i32 1, label %81
i32 2, label %76
]
76: ; preds = %73
%77 = getelementptr inbounds float, float* %1, i64 %67
%78 = load float, float* %77
%79 = fadd float %69, %78
%80 = fadd float %71, 1.000000e+00
br label %86
81: ; preds = %73
%82 = getelementptr inbounds float, float* %1, i64 %67
%83 = load float, float* %82
%84 = fadd float %68, %83
%85 = fadd float %70, 1.000000e+00
br label %86
86: ; preds = %73, %76, %81, %62
%87 = phi float [ %63, %62 ], [ %71, %81 ], [ %80, %76 ], [ %71, %73 ]
%88 = phi float [ %64, %62 ], [ %85, %81 ], [ %70, %76 ], [ %70, %73 ]
%89 = phi float [ %65, %62 ], [ %69, %81 ], [ %79, %76 ], [ %69, %73 ]
%90 = phi float [ %66, %62 ], [ %84, %81 ], [ %68, %76 ], [ %68, %73 ]
%91 = fdiv float %90, %88
%92 = fdiv float %89, %87
%93 = fdiv float %91, %92
br label %94
94: ; preds = %86, %8
%95 = phi float [ %93, %86 ], [ 0x7FF8000000000000, %8 ]
%96 = load float, float* %5
%97 = load float, float* %3
%98 = load float, float* %2
%99 = load float, float* %4
%100 = sitofp i32 %6 to float
%101 = fdiv float 2.500000e+00, %100
%102 = tail call float @diff_stat_reg1_reg2(float %98, float %97, float %99, float %96, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%103 = sitofp i32 %7 to float
%104 = fdiv float 5.000000e+00, %103
%105 = insertelement <2 x float> poison, float %100, i64 0
%106 = shufflevector <2 x float> %105, <2 x float> poison, <2 x i32> zeroinitializer
%107 = fdiv <2 x float> <float 5.000000e+00, float 2.500000e-01>, %106
%108 = extractelement <2 x float> %107, i64 1
%109 = fcmp ogt float %104, %108
%110 = extractelement <2 x float> %107, i64 0
%111 = fcmp ogt float %110, %108
%112 = fmul float %104, -2.000000e+00
%113 = fmul float %110, 2.000000e+00
br label %114
114: ; preds = %235, %94
%115 = phi float [ %96, %94 ], [ %134, %235 ]
%116 = phi float [ %99, %94 ], [ %162, %235 ]
%117 = phi float [ %97, %94 ], [ %176, %235 ]
%118 = phi float [ %98, %94 ], [ %207, %235 ]
%119 = phi float [ %102, %94 ], [ %204, %235 ]
%120 = phi i32 [ 100, %94 ], [ %208, %235 ]
br label %121
121: ; preds = %114, %121
%122 = phi float [ %124, %121 ], [ %115, %114 ]
%123 = phi float [ %125, %121 ], [ %119, %114 ]
%124 = fadd float %122, -1.000000e+00
%125 = tail call float @diff_stat_reg1_reg2(float %118, float %117, float %116, float %124, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%126 = fcmp olt float %125, %123
br i1 %126, label %121, label %127
127: ; preds = %121, %127
%128 = phi float [ %130, %127 ], [ %124, %121 ]
%129 = phi float [ %131, %127 ], [ %125, %121 ]
%130 = fadd float %128, 5.000000e-01
%131 = tail call float @diff_stat_reg1_reg2(float %118, float %117, float %116, float %130, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%132 = fcmp olt float %131, %129
br i1 %132, label %127, label %133
133: ; preds = %127
%134 = fadd float %130, -5.000000e-01
br i1 %109, label %135, label %158
135: ; preds = %133, %149
%136 = phi i32 [ %150, %149 ], [ 1, %133 ]
%137 = phi float [ %147, %149 ], [ %129, %133 ]
%138 = phi float [ %146, %149 ], [ %116, %133 ]
%139 = phi float [ %151, %149 ], [ %104, %133 ]
%140 = icmp eq i32 %136, 0
%141 = fneg float %139
%142 = select i1 %140, float %139, float %141
br label %143
143: ; preds = %135, %143
%144 = phi float [ %146, %143 ], [ %138, %135 ]
%145 = phi float [ %147, %143 ], [ %137, %135 ]
%146 = fadd float %142, %144
%147 = tail call float @diff_stat_reg1_reg2(float %118, float %117, float %146, float %134, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%148 = fcmp olt float %147, %145
br i1 %148, label %143, label %149
149: ; preds = %143
%150 = sub nsw i32 1, %136
%151 = fmul float %139, 5.000000e-01
%152 = fcmp ogt float %151, %108
br i1 %152, label %135, label %153
153: ; preds = %149
%154 = fmul float %151, 2.000000e+00
%155 = icmp eq i32 %136, 1
%156 = fneg float %154
%157 = select i1 %155, float %154, float %156
br label %158
158: ; preds = %153, %133
%159 = phi float [ %129, %133 ], [ %145, %153 ]
%160 = phi float [ %116, %133 ], [ %146, %153 ]
%161 = phi float [ %112, %133 ], [ %157, %153 ]
%162 = fadd float %160, %161
br label %163
163: ; preds = %158, %163
%164 = phi float [ %166, %163 ], [ %117, %158 ]
%165 = phi float [ %167, %163 ], [ %159, %158 ]
%166 = fadd float %164, 1.000000e+00
%167 = tail call float @diff_stat_reg1_reg2(float %118, float %166, float %162, float %134, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%168 = fcmp olt float %167, %165
br i1 %168, label %163, label %169
169: ; preds = %163, %169
%170 = phi float [ %172, %169 ], [ %166, %163 ]
%171 = phi float [ %173, %169 ], [ %167, %163 ]
%172 = fadd float %170, -5.000000e-01
%173 = tail call float @diff_stat_reg1_reg2(float %118, float %172, float %162, float %134, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%174 = fcmp olt float %173, %171
br i1 %174, label %169, label %175
175: ; preds = %169
%176 = fadd float %172, 5.000000e-01
br i1 %111, label %177, label %199
177: ; preds = %175, %191
%178 = phi i32 [ %192, %191 ], [ 0, %175 ]
%179 = phi float [ %189, %191 ], [ %171, %175 ]
%180 = phi float [ %188, %191 ], [ %118, %175 ]
%181 = phi float [ %193, %191 ], [ %110, %175 ]
%182 = icmp eq i32 %178, 0
%183 = fneg float %181
%184 = select i1 %182, float %181, float %183
br label %185
185: ; preds = %177, %185
%186 = phi float [ %188, %185 ], [ %180, %177 ]
%187 = phi float [ %189, %185 ], [ %179, %177 ]
%188 = fadd float %184, %186
%189 = tail call float @diff_stat_reg1_reg2(float %188, float %176, float %162, float %134, float %95, i32* %0, float* %1, i32 %6, i32 %7)
%190 = fcmp olt float %189, %187
br i1 %190, label %185, label %191
191: ; preds = %185
%192 = sub nsw i32 1, %178
%193 = fmul float %181, 5.000000e-01
%194 = fcmp ogt float %193, %108
br i1 %194, label %177, label %195
195: ; preds = %191
%196 = fmul float %193, 2.000000e+00
%197 = icmp eq i32 %178, 1
%198 = fneg float %196
br i1 %197, label %199, label %203
199: ; preds = %175, %195
%200 = phi float [ %196, %195 ], [ %113, %175 ]
%201 = phi float [ %187, %195 ], [ %171, %175 ]
%202 = phi float [ %188, %195 ], [ %118, %175 ]
br label %203
203: ; preds = %195, %199
%204 = phi float [ %201, %199 ], [ %187, %195 ]
%205 = phi float [ %202, %199 ], [ %188, %195 ]
%206 = phi float [ %200, %199 ], [ %198, %195 ]
%207 = fadd float %205, %206
%208 = add nsw i32 %120, -1
%209 = icmp ult i32 %120, 2
br i1 %209, label %210, label %213
210: ; preds = %203
%211 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
%212 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.4, i64 0, i64 0))
br label %236
213: ; preds = %203
%214 = fsub float %176, %117
%215 = fpext float %214 to double
%216 = tail call i64 @fabs(double %215)
%217 = icmp sgt i64 %216, 0
br i1 %217, label %235, label %218
218: ; preds = %213
%219 = fsub float %134, %115
%220 = fpext float %219 to double
%221 = tail call i64 @fabs(double %220)
%222 = icmp sgt i64 %221, 0
br i1 %222, label %235, label %223
223: ; preds = %218
%224 = fsub float %207, %118
%225 = fpext float %224 to double
%226 = tail call i64 @fabs(double %225)
%227 = sitofp i64 %226 to float
%228 = fcmp olt float %101, %227
br i1 %228, label %235, label %229
229: ; preds = %223
%230 = fsub float %162, %116
%231 = fpext float %230 to double
%232 = tail call i64 @fabs(double %231)
%233 = sitofp i64 %232 to float
%234 = fcmp olt float %101, %233
br i1 %234, label %235, label %236
235: ; preds = %229, %223, %218, %213
br label %114
236: ; preds = %229, %210
%237 = fpext float %207 to double
%238 = fpext float %176 to double
%239 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), double %237, double %238)
%240 = fpext float %162 to double
%241 = fpext float %134 to double
%242 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), double %240, double %241)
store float %207, float* %2
store float %176, float* %3
store float %162, float* %4
store float %134, float* %5
ret void
}