#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
float FLT_MAX;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ otsu(float **, int, int, int);
float bidme(int **imgh, int **imgv, int I, int J, int **refh, int **refv, int X,
            int Y, float **warp, int w, int c, FILE *fm, int itp) {
  float min, d, MAX, XI, YJ;
  float v1, v2, aux;
  int i, j, m, n, ip, jp;
  int ha, hb, va, vb, x, y;
  XI = (float)X / I;
  YJ = (float)Y / J;
  MAX = 0;
  for (i = 0; i < I; i += 1 + itp)
    for (j = 0; j < J; j += 1 + itp) {
      ip = (int)(i * XI + 0.5);
      jp = (int)(j * YJ + 0.5);
      min = FLT_MAX;
      d = 0;
      for (m = -c / 2; m <= c / 2 && d < min; m++)
        for (n = -c / 2; n <= c / 2 && d < min; n++) {
          ha = hb = va = vb = 127;
          if (i + n >= 0 && i + n < I && j + m >= 0 && j + m < J) {
            ha = imgh[j + m][i + n];
            va = imgv[j + m][i + n];
          }
          if (ip + n >= 0 && ip + n < X && jp + m >= 0 && jp + m < Y) {
            hb = refh[jp + m][ip + n];
            vb = refv[jp + m][ip + n];
          }
          d += ((ha - hb) * (ha - hb) + (va - vb) * (va - vb)) *
               (1.0 / (255 * 255));
        }
      if (d < min)
        min = d;
      for (x = ip - w; x <= ip + w && min > 0.0; x++)
        if (x >= 0 && x < X) {
          for (y = jp - w; y <= jp + w && min > 0.0; y++)
            if (y >= 0 && y < Y) {
              d = 0;
              for (m = -c / 2; m <= c / 2 && d < min; m++)
                for (n = -c / 2; n <= c / 2 && d < min; n++) {
                  ha = hb = va = vb = 127;
                  if (i + n >= 0 && i + n < I && j + m >= 0 && j + m < J) {
                    ha = imgh[j + m][i + n];
                    va = imgv[j + m][i + n];
                  }
                  if (x + n >= 0 && x + n < X && y + m >= 0 && y + m < Y) {
                    hb = refh[y + m][x + n];
                    vb = refv[y + m][x + n];
                  }
                  d += ((ha - hb) * (ha - hb) + (va - vb) * (va - vb)) *
                       (1.0 / (255 * 255));
                }
              if (d < min)
                min = d;
            }
        }
      if (d > MAX)
        MAX = d;
      warp[j][i] = d;
    }
  if (MAX > 0) {
    if (itp == 1) {
      for (j = 0; j < J; j += 2)
        for (i = 1; i < I; i += 2) {
          v1 = (i - 1 >= 0) ? warp[j][i - 1] : 0;
          v2 = (i + 1 < I) ? warp[j][i + 1] : 0;
          warp[j][i] = (v1 + v2) / 2;
        }
      for (j = 1; j < J; j += 2)
        for (i = 0; i < I; i++) {
          v1 = (j - 1 >= 0) ? warp[j - 1][i] : 0;
          v2 = (j + 1 < J) ? warp[j + 1][i] : 0;
          warp[j][i] = (v1 + v2) / 2;
        }
    } else if (itp == 2) {
      for (j = 0; j < J; j += 3)
        for (i = 1; i < I; i += 3) {
          v1 = (i - 1 >= 0) ? warp[j][i - 1] : 0;
          v2 = (i + 2 < I) ? warp[j][i + 2] : 0;
          aux = (v2 - v1) / 3;
          warp[j][i] = v1 + aux;
          if (i + 1 < I)
            warp[j][i + 1] = v2 - aux;
        }
      for (j = 1; j < J; j += 3)
        for (i = 0; i < I; i++) {
          v1 = (j - 1 >= 0) ? warp[j - 1][i] : 0;
          v2 = (j + 2 < J) ? warp[j + 2][i] : 0;
          aux = (v2 - v1) / 3;
          warp[j][i] = v1 + aux;
          if (j + 1 < J)
            warp[j + 1][i] = v2 - aux;
        }
    }
    for (y = 0; y < J; y++)
      for (x = 0; x < I; x++)
        warp[y][x] = 255 * (warp[y][x] / MAX);
    if (fm) {
      fprintf(fm, "P2\n%d %d\n255\n", I, J);
      for (j = 0; j < J; j++) {
        for (i = 0; i < I; i++)
          fprintf(fm, " %d", 255 - (int)warp[j][i]);
        fprintf(fm, "\n");
      }
      fclose(fm);
    }
    otsu(warp, I, J, 255);
  }
  return MAX;
}


x86 assembly (clang, -O0):
<bidme>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl 0x18(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17ce <bidme+0x69e>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17b8 <bidme+0x688>
cvtsi2ssl -0x4c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe3e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
cvtsi2ssl -0x50(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe1d(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x60(%rbp)
mov    0x2de3(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xor    %eax,%eax
sub    0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
mov    0x30(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x79(%rbp)
jg     1256 <bidme+0x126>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
seta   %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1266 <bidme+0x136>
jmp    1431 <bidme+0x301>
xor    %eax,%eax
sub    0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%ecx
mov    0x30(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x7a(%rbp)
jg     12a6 <bidme+0x176>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
seta   %al
mov    %al,-0x7a(%rbp)
mov    -0x7a(%rbp),%al
test   $0x1,%al
jne    12b6 <bidme+0x186>
jmp    141e <bidme+0x2ee>
movl   $0x7f,-0x70(%rbp)
movl   $0x7f,-0x6c(%rbp)
movl   $0x7f,-0x68(%rbp)
movl   $0x7f,-0x64(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     134e <bidme+0x21e>
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    134e <bidme+0x21e>
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     134e <bidme+0x21e>
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    134e <bidme+0x21e>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     13ca <bidme+0x29a>
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13ca <bidme+0x29a>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     13ca <bidme+0x29a>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13ca <bidme+0x29a>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x64(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    -0x64(%rbp),%ecx
sub    -0x68(%rbp),%ecx
imul   %ecx,%eax
mov    -0x6c(%rbp),%ecx
sub    -0x70(%rbp),%ecx
mov    -0x6c(%rbp),%edx
sub    -0x70(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xc19(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1276 <bidme+0x146>
jmp    1423 <bidme+0x2f3>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1226 <bidme+0xf6>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    144e <bidme+0x31e>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x5c(%rbp),%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%ecx
mov    -0x5c(%rbp),%edx
add    0x28(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x7b(%rbp)
jg     1483 <bidme+0x353>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x7b(%rbp)
mov    -0x7b(%rbp),%al
test   $0x1,%al
jne    1493 <bidme+0x363>
jmp    1774 <bidme+0x644>
cmpl   $0x0,-0x74(%rbp)
jl     1761 <bidme+0x631>
mov    -0x74(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1761 <bidme+0x631>
mov    -0x60(%rbp),%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%ecx
mov    -0x60(%rbp),%edx
add    0x28(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x7c(%rbp)
jg     14de <bidme+0x3ae>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x7c(%rbp)
mov    -0x7c(%rbp),%al
test   $0x1,%al
jne    14ee <bidme+0x3be>
jmp    175c <bidme+0x62c>
cmpl   $0x0,-0x78(%rbp)
jl     1749 <bidme+0x619>
mov    -0x78(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1749 <bidme+0x619>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xor    %eax,%eax
sub    0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
mov    0x30(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x7d(%rbp)
jg     154c <bidme+0x41c>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
seta   %al
mov    %al,-0x7d(%rbp)
mov    -0x7d(%rbp),%al
test   $0x1,%al
jne    155c <bidme+0x42c>
jmp    1727 <bidme+0x5f7>
xor    %eax,%eax
sub    0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%ecx
mov    0x30(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x7e(%rbp)
jg     159c <bidme+0x46c>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
seta   %al
mov    %al,-0x7e(%rbp)
mov    -0x7e(%rbp),%al
test   $0x1,%al
jne    15ac <bidme+0x47c>
jmp    1714 <bidme+0x5e4>
movl   $0x7f,-0x70(%rbp)
movl   $0x7f,-0x6c(%rbp)
movl   $0x7f,-0x68(%rbp)
movl   $0x7f,-0x64(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1644 <bidme+0x514>
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1644 <bidme+0x514>
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     1644 <bidme+0x514>
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1644 <bidme+0x514>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x74(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     16c0 <bidme+0x590>
mov    -0x74(%rbp),%eax
add    -0x58(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16c0 <bidme+0x590>
mov    -0x78(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     16c0 <bidme+0x590>
mov    -0x78(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16c0 <bidme+0x590>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x74(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x74(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x64(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    -0x64(%rbp),%ecx
sub    -0x68(%rbp),%ecx
imul   %ecx,%eax
mov    -0x6c(%rbp),%ecx
sub    -0x70(%rbp),%ecx
mov    -0x6c(%rbp),%edx
sub    -0x70(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x923(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    156c <bidme+0x43c>
jmp    1719 <bidme+0x5e9>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    151c <bidme+0x3ec>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1744 <bidme+0x614>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    1749 <bidme+0x619>
jmp    174e <bidme+0x61e>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14b2 <bidme+0x382>
jmp    1761 <bidme+0x631>
jmp    1766 <bidme+0x636>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1457 <bidme+0x327>
movss  -0x30(%rbp),%xmm0
ucomiss -0x34(%rbp),%xmm0
jbe    178d <bidme+0x65d>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x40(%rbp),%eax
add    $0x1,%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    11b0 <bidme+0x80>
jmp    17bd <bidme+0x68d>
mov    0x40(%rbp),%eax
add    $0x1,%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    119d <bidme+0x6d>
movss  -0x34(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1e34 <bidme+0xd04>
cmpl   $0x1,0x40(%rbp)
jne    1a1e <bidme+0x8ee>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1901 <bidme+0x7d1>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18ee <bidme+0x7be>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     1845 <bidme+0x715>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    1855 <bidme+0x725>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    1855 <bidme+0x725>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jge    1898 <bidme+0x768>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    18a8 <bidme+0x778>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    18a8 <bidme+0x778>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  0x741(%rip),%xmm1
divss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    1803 <bidme+0x6d3>
jmp    18f3 <bidme+0x7c3>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
jmp    17f0 <bidme+0x6c0>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a19 <bidme+0x8e9>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a06 <bidme+0x8d6>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     195d <bidme+0x82d>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    196d <bidme+0x83d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    196d <bidme+0x83d>
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    19b0 <bidme+0x880>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    19c0 <bidme+0x890>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    19c0 <bidme+0x890>
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  0x629(%rip),%xmm1
divss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    191b <bidme+0x7eb>
jmp    1a0b <bidme+0x8db>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
jmp    1908 <bidme+0x7d8>
jmp    1cf0 <bidme+0xbc0>
cmpl   $0x2,0x40(%rbp)
jne    1ceb <bidme+0xbbb>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b87 <bidme+0xa57>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b74 <bidme+0xa44>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     1a84 <bidme+0x954>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1a94 <bidme+0x964>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1a94 <bidme+0x964>
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
cmp    -0x14(%rbp),%eax
jge    1ad7 <bidme+0x9a7>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1ae7 <bidme+0x9b7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1ae7 <bidme+0x9b7>
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  0x4fa(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jge    1b61 <bidme+0xa31>
movss  -0x44(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b66 <bidme+0xa36>
mov    -0x4c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a42 <bidme+0x912>
jmp    1b79 <bidme+0xa49>
mov    -0x50(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x50(%rbp)
jmp    1a2f <bidme+0x8ff>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ce6 <bidme+0xbb6>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1cd3 <bidme+0xba3>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     1be3 <bidme+0xab3>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
jmp    1bf3 <bidme+0xac3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
jmp    1bf3 <bidme+0xac3>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
cmp    -0x18(%rbp),%eax
jge    1c36 <bidme+0xb06>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1c46 <bidme+0xb16>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1c46 <bidme+0xb16>
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  0x39b(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    1cc0 <bidme+0xb90>
movss  -0x44(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1cc5 <bidme+0xb95>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1ba1 <bidme+0xa71>
jmp    1cd8 <bidme+0xba8>
mov    -0x50(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x50(%rbp)
jmp    1b8e <bidme+0xa5e>
jmp    1ceb <bidme+0xbbb>
jmp    1cf0 <bidme+0xbc0>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d72 <bidme+0xc42>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d5f <bidme+0xc2f>
mov    0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
divss  -0x34(%rbp),%xmm1
movss  0x2cc(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1d0a <bidme+0xbda>
jmp    1d64 <bidme+0xc34>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1cf7 <bidme+0xbc7>
cmpq   $0x0,0x38(%rbp)
je     1e20 <bidme+0xcf0>
mov    0x38(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
lea    0x292(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1e17 <bidme+0xce7>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1df7 <bidme+0xcc7>
mov    0x38(%rbp),%rdi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    $0xff,%edx
sub    %eax,%edx
lea    0x24c(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1daf <bidme+0xc7f>
mov    0x38(%rbp),%rdi
lea    0x22a(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1d9c <bidme+0xc6c>
mov    0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    $0xff,%ecx
call   1040 <otsu@plt>
movss  -0x34(%rbp),%xmm0
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bidme>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0x68(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rdi,0x58(%rsp)
test   %edx,%edx
jle    16fa <bidme+0x5ba>
mov    0xf0(%rsp),%esi
mov    0xe0(%rsp),%eax
cvtsi2ssl 0xc0(%rsp),%xmm8
cvtsi2ss %edx,%xmm2
cvtsi2ssl 0xc8(%rsp),%xmm1
mov    0xd0(%rsp),%rbx
cvtsi2ss %ecx,%xmm3
divss  %xmm2,%xmm8
divss  %xmm3,%xmm1
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
sar    %edi
mov    %edi,0x18(%rsp)
neg    %edi
mov    %edi,0xc(%rsp)
lea    0x1(%rsi),%eax
cltq
mov    %rax,0x50(%rsp)
movslq %ecx,%rax
mov    %rax,0x78(%rsp)
mov    %edx,%eax
mov    %rax,0x10(%rsp)
xorps  %xmm2,%xmm2
xor    %eax,%eax
mov    %rax,0x30(%rsp)
movsd  0xe1a(%rip),%xmm9
movsd  0xe1a(%rip),%xmm4
xorps  %xmm0,%xmm0
mov    %ecx,0x8(%rsp)
mov    %edx,0x4(%rsp)
jmp    1220 <bidme+0xe0>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbp
add    0x50(%rsp),%rbp
mov    0x10(%rsp),%rax
mov    %rbp,%rdi
mov    %rbp,0x30(%rsp)
cmp    %rax,%rbp
jge    164d <bidme+0x50d>
test   %ecx,%ecx
jle    1200 <bidme+0xc0>
xorps  %xmm5,%xmm5
cvtsi2ssl 0x30(%rsp),%xmm5
mulss  %xmm8,%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm9,%xmm5
cvttsd2si %xmm5,%r8d
mov    %r8d,%ecx
mov    0xd8(%rsp),%eax
sub    %eax,%ecx
mov    %ecx,0x20(%rsp)
add    %r8d,%eax
mov    %eax,0x28(%rsp)
xor    %edi,%edi
movaps %xmm0,%xmm5
mov    %r8,0x80(%rsp)
jmp    12ad <bidme+0x16d>
cs nopw 0x0(%rax,%rax,1)
mov    0xd0(%rsp),%rbx
mov    0x40(%rsp),%rdi
mov    (%rbx,%rdi,8),%rax
mov    0x30(%rsp),%rcx
movss  %xmm0,(%rax,%rcx,4)
maxss  %xmm5,%xmm0
add    0x50(%rsp),%rdi
movaps %xmm0,%xmm5
cmp    0x78(%rsp),%rdi
mov    0x8(%rsp),%ecx
mov    0xf0(%rsp),%esi
jge    1200 <bidme+0xc0>
mov    0x2d34(%rip),%rax
movss  (%rax),%xmm7
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm7
xorps  %xmm6,%xmm6
cvtsi2ss %edi,%xmm6
seta   %al
mulss  %xmm1,%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm9,%xmm6
cvttsd2si %xmm6,%r13d
mov    0xc(%rsp),%ecx
cmp    0x18(%rsp),%ecx
mov    %rdi,0x40(%rsp)
jg     1412 <bidme+0x2d2>
ucomiss %xmm2,%xmm7
jbe    1412 <bidme+0x2d2>
xorps  %xmm0,%xmm0
mov    0xc(%rsp),%r10d
xchg   %ax,%ax
ucomiss %xmm0,%xmm7
jbe    13f8 <bidme+0x2b8>
mov    %r10d,%r11d
add    0x40(%rsp),%r11d
sets   %al
cmp    0x8(%rsp),%r11d
setge  %r15b
mov    %r10d,%r14d
add    %r13d,%r14d
sets   %cl
cmp    0xc8(%rsp),%r14d
setge  %r12b
or     %al,%r15b
or     %cl,%r12b
mov    0xc(%rsp),%edi
nopl   0x0(%rax)
mov    0x30(%rsp),%rax
mov    %eax,%ecx
add    %edi,%ecx
sets   %sil
cmp    %edx,%ecx
setge  %bl
or     %sil,%bl
or     %r15b,%bl
mov    $0x7f,%r9d
mov    $0x7f,%ebx
mov    $0x7f,%ebp
jne    1384 <bidme+0x244>
mov    0x58(%rsp),%rax
mov    (%rax,%r11,8),%rsi
mov    %ecx,%ecx
mov    (%rsi,%rcx,4),%ebx
mov    0x60(%rsp),%rax
mov    (%rax,%r11,8),%rsi
mov    (%rsi,%rcx,4),%ebp
mov    %r8d,%ecx
add    %edi,%ecx
sets   %sil
cmp    0xc0(%rsp),%ecx
setge  %al
or     %sil,%al
or     %r12b,%al
mov    $0x7f,%esi
jne    13bf <bidme+0x27f>
mov    0x68(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%r9d
mov    0x70(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rcx,4),%esi
sub    %esi,%ebp
sub    %r9d,%ebx
imul   %ebx,%ebx
imul   %ebp,%ebp
add    %ebx,%ebp
xorps  %xmm6,%xmm6
cvtsi2sd %ebp,%xmm6
cvtss2sd %xmm0,%xmm0
mulsd  %xmm4,%xmm6
addsd  %xmm0,%xmm6
xorps  %xmm0,%xmm0
cvtsd2ss %xmm6,%xmm0
cmp    0x18(%rsp),%edi
jge    13f8 <bidme+0x2b8>
add    $0x1,%edi
ucomiss %xmm0,%xmm7
ja     1340 <bidme+0x200>
ucomiss %xmm0,%xmm7
seta   %al
cmp    0x18(%rsp),%r10d
jge    1412 <bidme+0x2d2>
add    $0x1,%r10d
ucomiss %xmm0,%xmm7
ja     1300 <bidme+0x1c0>
movaps %xmm0,%xmm6
test   %al,%al
jne    141c <bidme+0x2dc>
movaps %xmm7,%xmm6
mov    0x28(%rsp),%eax
cmp    %eax,0x20(%rsp)
jg     1270 <bidme+0x130>
ucomiss %xmm2,%xmm6
jbe    1270 <bidme+0x130>
mov    %r13d,%ecx
mov    0xd8(%rsp),%eax
sub    %eax,%ecx
mov    %ecx,0x24(%rsp)
add    %eax,%r13d
mov    0x20(%rsp),%r10d
mov    %r13d,0x4c(%rsp)
test   %r10d,%r10d
js     1630 <bidme+0x4f0>
cmp    0xc0(%rsp),%r10d
jge    1630 <bidme+0x4f0>
cmp    %r13d,0x24(%rsp)
jg     1630 <bidme+0x4f0>
ucomiss %xmm2,%xmm6
jbe    1630 <bidme+0x4f0>
mov    0x24(%rsp),%eax
nop
test   %eax,%eax
js     161c <bidme+0x4dc>
cmp    0xc8(%rsp),%eax
jge    161c <bidme+0x4dc>
mov    %eax,0x2c(%rsp)
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm6
seta   %cl
mov    0xc(%rsp),%eax
cmp    0x18(%rsp),%eax
jg     15fe <bidme+0x4be>
ucomiss %xmm2,%xmm6
jbe    15fe <bidme+0x4be>
xorps  %xmm0,%xmm0
mov    0xc(%rsp),%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm6
jbe    15e4 <bidme+0x4a4>
mov    %r13d,%r15d
add    0x40(%rsp),%r15d
sets   %sil
cmp    0x8(%rsp),%r15d
setge  %bl
mov    %r13d,%r12d
add    0x2c(%rsp),%r12d
sets   %cl
cmp    0xc8(%rsp),%r12d
setge  %r14b
or     %sil,%bl
or     %cl,%r14b
mov    0xc(%rsp),%r11d
nop
mov    0x30(%rsp),%rax
mov    %eax,%r8d
add    %r11d,%r8d
sets   %cl
cmp    %edx,%r8d
setge  %dl
or     %cl,%dl
or     %bl,%dl
mov    $0x7f,%r9d
mov    $0x7f,%ebp
mov    $0x7f,%ecx
jne    1555 <bidme+0x415>
mov    0x58(%rsp),%rax
mov    (%rax,%r15,8),%rcx
mov    %r8d,%edx
mov    (%rcx,%rdx,4),%ebp
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rcx
mov    (%rcx,%rdx,4),%ecx
mov    %r10d,%esi
add    %r11d,%esi
sets   %dl
cmp    0xc0(%rsp),%esi
setge  %al
or     %dl,%al
or     %r14b,%al
mov    $0x7f,%edi
jne    158f <bidme+0x44f>
mov    0x68(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    %esi,%edx
mov    (%rax,%rdx,4),%r9d
mov    0x70(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rdx,4),%edi
sub    %edi,%ecx
sub    %r9d,%ebp
imul   %ebp,%ebp
imul   %ecx,%ecx
add    %ebp,%ecx
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
xorps  %xmm7,%xmm7
cvtss2sd %xmm0,%xmm7
mulsd  %xmm4,%xmm3
addsd  %xmm7,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
cmp    0x18(%rsp),%r11d
jge    15e0 <bidme+0x4a0>
add    $0x1,%r11d
ucomiss %xmm0,%xmm6
mov    0x4(%rsp),%edx
ja     1510 <bidme+0x3d0>
jmp    15e4 <bidme+0x4a4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%rsp),%edx
ucomiss %xmm0,%xmm6
seta   %cl
cmp    0x18(%rsp),%r13d
jge    15fe <bidme+0x4be>
add    $0x1,%r13d
ucomiss %xmm0,%xmm6
ja     14d0 <bidme+0x390>
movaps %xmm0,%xmm7
test   %cl,%cl
jne    1608 <bidme+0x4c8>
movaps %xmm6,%xmm7
movaps %xmm7,%xmm6
mov    0x80(%rsp),%r8
mov    0x4c(%rsp),%r13d
mov    0x2c(%rsp),%eax
cmp    %r13d,%eax
jge    1630 <bidme+0x4f0>
add    $0x1,%eax
ucomiss %xmm2,%xmm6
ja     1480 <bidme+0x340>
nopl   (%rax)
cmp    0x28(%rsp),%r10d
jge    1270 <bidme+0x130>
add    $0x1,%r10d
ucomiss %xmm2,%xmm6
ja     1450 <bidme+0x310>
jmp    1270 <bidme+0x130>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1bfc <bidme+0xabc>
cmp    $0x1,%esi
je     1702 <bidme+0x5c2>
cmp    $0x2,%esi
mov    0xe8(%rsp),%rdi
jne    19df <bidme+0x89f>
test   %ecx,%ecx
jle    1b00 <bidme+0x9c0>
movslq 0x4(%rsp),%rax
mov    %ecx,%r8d
xor    %edx,%edx
movss  0x983(%rip),%xmm4
jmp    169d <bidme+0x55d>
nop
add    $0x3,%rdx
cmp    %r8,%rdx
jae    1809 <bidme+0x6c9>
cmpl   $0x2,0x4(%rsp)
jl     1690 <bidme+0x550>
mov    (%rbx,%rdx,8),%rsi
mov    $0x1,%edi
jmp    16b9 <bidme+0x579>
nop
add    $0x3,%rdi
cmp    %rax,%rdi
jge    1690 <bidme+0x550>
lea    0x2(%rdi),%rbp
xorps  %xmm1,%xmm1
cmp    %rax,%rbp
jge    16cb <bidme+0x58b>
movss  0x8(%rsi,%rdi,4),%xmm1
movss  -0x4(%rsi,%rdi,4),%xmm3
movaps %xmm1,%xmm2
subss  %xmm3,%xmm2
divss  %xmm4,%xmm2
addss  %xmm2,%xmm3
movss  %xmm3,(%rsi,%rdi,4)
lea    0x1(%rdi),%rbp
cmp    %rax,%rbp
jge    16b0 <bidme+0x570>
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%rsi,%rdi,4)
jmp    16b0 <bidme+0x570>
xorps  %xmm0,%xmm0
jmp    1bfc <bidme+0xabc>
test   %ecx,%ecx
jle    1b09 <bidme+0x9c9>
movslq %edx,%rax
mov    %ecx,%r11d
lea    -0x2(%rax),%r9
mov    %r9,%r10
shr    %r10
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %ebx,%ebx
movss  0x8e5(%rip),%xmm3
jmp    175c <bidme+0x61c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addss  -0x4(%rdi,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%rdi,%rdx,4)
add    $0x2,%rbx
cmp    %r11,%rbx
jae    18e5 <bidme+0x7a5>
cmpl   $0x2,0x4(%rsp)
jl     174f <bidme+0x60f>
mov    0xd0(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdi
mov    $0x1,%edx
cmp    $0x2,%r9
jb     17e4 <bidme+0x6a4>
mov    $0x2,%edx
mov    %r8,%rbp
jmp    17a9 <bidme+0x669>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  (%rdi,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0x4(%rdi,%rdx,4)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rbp
je     17e0 <bidme+0x6a0>
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
cmp    %rax,%rdx
jge    17b9 <bidme+0x679>
movss  (%rdi,%rdx,4),%xmm2
addss  -0x8(%rdi,%rdx,4),%xmm2
mulss  %xmm3,%xmm2
movss  %xmm2,-0x4(%rdi,%rdx,4)
lea    0x2(%rdx),%rsi
cmp    %rax,%rsi
jge    1790 <bidme+0x650>
movss  0x8(%rdi,%rdx,4),%xmm1
jmp    1790 <bidme+0x650>
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdx
test   $0x1,%r10b
je     174f <bidme+0x60f>
lea    0x1(%rdx),%rsi
xorps  %xmm1,%xmm1
cmp    %rax,%rsi
jge    1740 <bidme+0x600>
movss  0x4(%rdi,%rdx,4),%xmm1
jmp    1740 <bidme+0x600>
cmp    $0x2,%ecx
mov    0xe8(%rsp),%rdi
mov    0x10(%rsp),%rax
jl     19df <bidme+0x89f>
mov    $0x1,%edx
jmp    1845 <bidme+0x705>
cs nopw 0x0(%rax,%rax,1)
add    $0x3,%rdx
cmp    %r8,%rdx
mov    0xd0(%rsp),%rbx
jae    19df <bidme+0x89f>
cmpl   $0x0,0x4(%rsp)
jle    1830 <bidme+0x6f0>
mov    0xd0(%rsp),%rax
mov    -0x8(%rax,%rdx,8),%r9
mov    (%rax,%rdx,8),%r10
mov    0x10(%rsp),%rax
lea    0x2(%rdx),%rsi
lea    0x1(%rdx),%rbp
xor    %ebx,%ebx
jmp    1879 <bidme+0x739>
xchg   %ax,%ax
add    $0x1,%rbx
cmp    %rbx,%rax
je     1830 <bidme+0x6f0>
xorps  %xmm1,%xmm1
cmp    %r8,%rsi
jae    18a0 <bidme+0x760>
mov    0xd0(%rsp),%rax
mov    0x10(%rax,%rdx,8),%rax
movss  (%rax,%rbx,4),%xmm1
mov    0x10(%rsp),%rax
mov    0xe8(%rsp),%rdi
movss  (%r9,%rbx,4),%xmm3
movaps %xmm1,%xmm2
subss  %xmm3,%xmm2
divss  %xmm4,%xmm2
addss  %xmm2,%xmm3
movss  %xmm3,(%r10,%rbx,4)
cmp    %r8,%rbp
jae    1870 <bidme+0x730>
subss  %xmm2,%xmm1
mov    0xd0(%rsp),%rax
mov    0x8(%rax,%rdx,8),%rax
movss  %xmm1,(%rax,%rbx,4)
mov    0x10(%rsp),%rax
mov    0xe8(%rsp),%rdi
jmp    1870 <bidme+0x730>
mov    0x8(%rsp),%ecx
cmp    $0x2,%ecx
mov    0xe8(%rsp),%rdi
mov    0xd0(%rsp),%rbx
mov    0x10(%rsp),%rax
jl     19df <bidme+0x89f>
mov    %eax,%r8d
and    $0xfffffffe,%r8d
mov    $0x1,%r9d
jmp    1948 <bidme+0x808>
cs nopw 0x0(%rax,%rax,1)
addss  (%rdi,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
add    $0x2,%r9
cmp    %r11,%r9
mov    0xe8(%rsp),%rdi
mov    0x10(%rsp),%rax
jae    19df <bidme+0x89f>
cmpl   $0x0,0x4(%rsp)
jle    192e <bidme+0x7ee>
lea    0x1(%r9),%rax
mov    -0x8(%rbx,%r9,8),%rdi
mov    (%rbx,%r9,8),%rsi
cmpl   $0x1,0x4(%rsp)
jne    1980 <bidme+0x840>
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
je     192e <bidme+0x7ee>
xorps  %xmm1,%xmm1
cmp    %r11,%rax
jae    1920 <bidme+0x7e0>
mov    0x8(%rbx,%r9,8),%rax
movss  (%rax,%rdx,4),%xmm1
jmp    1920 <bidme+0x7e0>
xor    %edx,%edx
jmp    19a9 <bidme+0x869>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  0x4(%rdi,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0x4(%rsi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r8
je     1965 <bidme+0x825>
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
cmp    %r11,%rax
jae    19bf <bidme+0x87f>
mov    0x8(%rbx,%r9,8),%rbp
movss  0x0(%rbp,%rdx,4),%xmm2
addss  (%rdi,%rdx,4),%xmm2
mulss  %xmm3,%xmm2
movss  %xmm2,(%rsi,%rdx,4)
cmp    %r11,%rax
jae    1990 <bidme+0x850>
mov    0x8(%rbx,%r9,8),%rbp
movss  0x4(%rbp,%rdx,4),%xmm1
jmp    1990 <bidme+0x850>
test   %ecx,%ecx
setg   %r14b
jle    1b00 <bidme+0x9c0>
mov    %rax,%rsi
mov    %ecx,%eax
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %ebx,%ebx
movss  0x5fe(%rip),%xmm1
movaps 0x5ff(%rip),%xmm2
jmp    1a3d <bidme+0x8fd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
cmp    %rax,%rbx
je     1aea <bidme+0x9aa>
cmpl   $0x0,0x4(%rsp)
jle    1a30 <bidme+0x8f0>
mov    0xd0(%rsp),%rdx
mov    (%rdx,%rbx,8),%rdi
cmpl   $0x4,0x4(%rsp)
jae    1a60 <bidme+0x920>
xor    %edx,%edx
mov    0x10(%rsp),%rbp
jmp    1ac0 <bidme+0x980>
test   %r9,%r9
je     1ae0 <bidme+0x9a0>
mov    %r8,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rbp,4),%xmm3
movups 0x10(%rdi,%rbp,4),%xmm4
divps  %xmm5,%xmm3
mulps  %xmm2,%xmm3
movups %xmm3,(%rdi,%rbp,4)
divps  %xmm5,%xmm4
mulps  %xmm2,%xmm4
movups %xmm4,0x10(%rdi,%rbp,4)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1a70 <bidme+0x930>
test   $0x1,%r10b
je     1aac <bidme+0x96c>
movups (%rdi,%rbp,4),%xmm3
divps  %xmm5,%xmm3
mulps  %xmm2,%xmm3
movups %xmm3,(%rdi,%rbp,4)
mov    %rsi,%rdx
mov    0x10(%rsp),%rbp
cmp    %rbp,%rsi
je     1a30 <bidme+0x8f0>
nopl   (%rax)
movss  (%rdi,%rdx,4),%xmm3
divss  %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  %xmm3,(%rdi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1ac0 <bidme+0x980>
jmp    1a30 <bidme+0x8f0>
xor    %ebp,%ebp
test   $0x1,%r10b
jne    1a9e <bidme+0x95e>
jmp    1aac <bidme+0x96c>
mov    0x4(%rsp),%edx
mov    0xe8(%rsp),%rdi
mov    0xd0(%rsp),%rbx
jmp    1b14 <bidme+0x9d4>
xor    %r14d,%r14d
mov    0x4(%rsp),%edx
jmp    1b14 <bidme+0x9d4>
xor    %r14d,%r14d
mov    0xe8(%rsp),%rdi
movaps %xmm0,0x30(%rsp)
test   %rdi,%rdi
je     1be6 <bidme+0xaa6>
lea    0x507(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
test   %r14b,%r14b
je     1bc9 <bidme+0xa89>
mov    0x8(%rsp),%eax
mov    %rax,0x18(%rsp)
lea    0x4f5(%rip),%r12
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
jmp    1b78 <bidme+0xa38>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xa,%edi
mov    %r15,%rsi
call   1050 <fputc@plt>
add    $0x1,%rbp
cmp    0x18(%rsp),%rbp
je     1bc9 <bidme+0xa89>
cmpl   $0x0,0x4(%rsp)
mov    0xe8(%rsp),%r15
mov    0xd0(%rsp),%r13
jle    1b60 <bidme+0xa20>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,8),%rax
cvttss2si (%rax,%rbx,4),%eax
mov    $0xff,%edx
sub    %eax,%edx
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1ba0 <bidme+0xa60>
jmp    1b60 <bidme+0xa20>
mov    0xe8(%rsp),%rdi
call   1030 <fclose@plt>
mov    0x8(%rsp),%ecx
mov    0x4(%rsp),%edx
mov    0xd0(%rsp),%rbx
mov    %rbx,%rdi
mov    %edx,%esi
mov    %ecx,%edx
mov    $0xff,%ecx
call   1040 <otsu@plt>
movaps 0x30(%rsp),%xmm0
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@FLT_MAX = global float 0.000000e+00
@.str = [14 x i8] c"P2\0A%d %d\0A255\0A\00"
@.str.1 = [4 x i8] c" %d\00"
@.str.2 = [2 x i8] c"\0A\00"
define float @bidme(i32** %0, i32** %1, i32 %2, i32 %3, i32** %4, i32** %5, i32 %6, i32 %7, float** %8, i32 %9, i32 %10, i32* %11, i32 %12) {
%14 = alloca i32**
%15 = alloca i32**
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32**
%19 = alloca i32**
%20 = alloca i32
%21 = alloca i32
%22 = alloca float**
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32*
%26 = alloca i32
%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 i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
store i32** %0, i32*** %14
store i32** %1, i32*** %15
store i32 %2, i32* %16
store i32 %3, i32* %17
store i32** %4, i32*** %18
store i32** %5, i32*** %19
store i32 %6, i32* %20
store i32 %7, i32* %21
store float** %8, float*** %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32* %11, i32** %25
store i32 %12, i32* %26
%47 = load i32, i32* %20
%48 = sitofp i32 %47 to float
%49 = load i32, i32* %16
%50 = sitofp i32 %49 to float
%51 = fdiv float %48, %50
store float %51, float* %30
%52 = load i32, i32* %21
%53 = sitofp i32 %52 to float
%54 = load i32, i32* %17
%55 = sitofp i32 %54 to float
%56 = fdiv float %53, %55
store float %56, float* %31
store float 0.000000e+00, float* %29
store i32 0, i32* %35
br label %57
57: ; preds = %483, %13
%58 = load i32, i32* %35
%59 = load i32, i32* %16
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %488
61: ; preds = %57
store i32 0, i32* %36
br label %62
62: ; preds = %477, %61
%63 = load i32, i32* %36
%64 = load i32, i32* %17
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %482
66: ; preds = %62
%67 = load i32, i32* %35
%68 = sitofp i32 %67 to float
%69 = load float, float* %30
%70 = fmul float %68, %69
%71 = fpext float %70 to double
%72 = fadd double %71, 5.000000e-01
%73 = fptosi double %72 to i32
store i32 %73, i32* %39
%74 = load i32, i32* %36
%75 = sitofp i32 %74 to float
%76 = load float, float* %31
%77 = fmul float %75, %76
%78 = fpext float %77 to double
%79 = fadd double %78, 5.000000e-01
%80 = fptosi double %79 to i32
store i32 %80, i32* %40
%81 = load float, float* @FLT_MAX
store float %81, float* %27
store float 0.000000e+00, float* %28
%82 = load i32, i32* %24
%83 = sub nsw i32 0, %82
%84 = sdiv i32 %83, 2
store i32 %84, i32* %37
br label %85
85: ; preds = %234, %66
%86 = load i32, i32* %37
%87 = load i32, i32* %24
%88 = sdiv i32 %87, 2
%89 = icmp sle i32 %86, %88
br i1 %89, label %90, label %94
90: ; preds = %85
%91 = load float, float* %28
%92 = load float, float* %27
%93 = fcmp olt float %91, %92
br label %94
94: ; preds = %90, %85
%95 = phi i1 [ false, %85 ], [ %93, %90 ]
br i1 %95, label %96, label %237
96: ; preds = %94
%97 = load i32, i32* %24
%98 = sub nsw i32 0, %97
%99 = sdiv i32 %98, 2
store i32 %99, i32* %38
br label %100
100: ; preds = %230, %96
%101 = load i32, i32* %38
%102 = load i32, i32* %24
%103 = sdiv i32 %102, 2
%104 = icmp sle i32 %101, %103
br i1 %104, label %105, label %109
105: ; preds = %100
%106 = load float, float* %28
%107 = load float, float* %27
%108 = fcmp olt float %106, %107
br label %109
109: ; preds = %105, %100
%110 = phi i1 [ false, %100 ], [ %108, %105 ]
br i1 %110, label %111, label %233
111: ; preds = %109
store i32 127, i32* %44
store i32 127, i32* %43
store i32 127, i32* %42
store i32 127, i32* %41
%112 = load i32, i32* %35
%113 = load i32, i32* %38
%114 = add nsw i32 %112, %113
%115 = icmp sge i32 %114, 0
br i1 %115, label %116, label %160
116: ; preds = %111
%117 = load i32, i32* %35
%118 = load i32, i32* %38
%119 = add nsw i32 %117, %118
%120 = load i32, i32* %16
%121 = icmp slt i32 %119, %120
br i1 %121, label %122, label %160
122: ; preds = %116
%123 = load i32, i32* %36
%124 = load i32, i32* %37
%125 = add nsw i32 %123, %124
%126 = icmp sge i32 %125, 0
br i1 %126, label %127, label %160
127: ; preds = %122
%128 = load i32, i32* %36
%129 = load i32, i32* %37
%130 = add nsw i32 %128, %129
%131 = load i32, i32* %17
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %160
133: ; preds = %127
%134 = load i32**, i32*** %14
%135 = load i32, i32* %36
%136 = load i32, i32* %37
%137 = add nsw i32 %135, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32*, i32** %134, i64 %138
%140 = load i32*, i32** %139
%141 = load i32, i32* %35
%142 = load i32, i32* %38
%143 = add nsw i32 %141, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %140, i64 %144
%146 = load i32, i32* %145
store i32 %146, i32* %41
%147 = load i32**, i32*** %15
%148 = load i32, i32* %36
%149 = load i32, i32* %37
%150 = add nsw i32 %148, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32*, i32** %147, i64 %151
%153 = load i32*, i32** %152
%154 = load i32, i32* %35
%155 = load i32, i32* %38
%156 = add nsw i32 %154, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %153, i64 %157
%159 = load i32, i32* %158
store i32 %159, i32* %43
br label %160
160: ; preds = %133, %127, %122, %116, %111
%161 = load i32, i32* %39
%162 = load i32, i32* %38
%163 = add nsw i32 %161, %162
%164 = icmp sge i32 %163, 0
br i1 %164, label %165, label %209
165: ; preds = %160
%166 = load i32, i32* %39
%167 = load i32, i32* %38
%168 = add nsw i32 %166, %167
%169 = load i32, i32* %20
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %209
171: ; preds = %165
%172 = load i32, i32* %40
%173 = load i32, i32* %37
%174 = add nsw i32 %172, %173
%175 = icmp sge i32 %174, 0
br i1 %175, label %176, label %209
176: ; preds = %171
%177 = load i32, i32* %40
%178 = load i32, i32* %37
%179 = add nsw i32 %177, %178
%180 = load i32, i32* %21
%181 = icmp slt i32 %179, %180
br i1 %181, label %182, label %209
182: ; preds = %176
%183 = load i32**, i32*** %18
%184 = load i32, i32* %40
%185 = load i32, i32* %37
%186 = add nsw i32 %184, %185
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32*, i32** %183, i64 %187
%189 = load i32*, i32** %188
%190 = load i32, i32* %39
%191 = load i32, i32* %38
%192 = add nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %189, i64 %193
%195 = load i32, i32* %194
store i32 %195, i32* %42
%196 = load i32**, i32*** %19
%197 = load i32, i32* %40
%198 = load i32, i32* %37
%199 = add nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i32*, i32** %196, i64 %200
%202 = load i32*, i32** %201
%203 = load i32, i32* %39
%204 = load i32, i32* %38
%205 = add nsw i32 %203, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %202, i64 %206
%208 = load i32, i32* %207
store i32 %208, i32* %44
br label %209
209: ; preds = %182, %176, %171, %165, %160
%210 = load i32, i32* %41
%211 = load i32, i32* %42
%212 = sub nsw i32 %210, %211
%213 = load i32, i32* %41
%214 = load i32, i32* %42
%215 = sub nsw i32 %213, %214
%216 = mul nsw i32 %212, %215
%217 = load i32, i32* %43
%218 = load i32, i32* %44
%219 = sub nsw i32 %217, %218
%220 = load i32, i32* %43
%221 = load i32, i32* %44
%222 = sub nsw i32 %220, %221
%223 = mul nsw i32 %219, %222
%224 = add nsw i32 %216, %223
%225 = sitofp i32 %224 to double
%226 = load float, float* %28
%227 = fpext float %226 to double
%228 = call double @llvm.fmuladd.f64(double %225, double 0x3EF0203040506071, double %227)
%229 = fptrunc double %228 to float
store float %229, float* %28
br label %230
230: ; preds = %209
%231 = load i32, i32* %38
%232 = add nsw i32 %231, 1
store i32 %232, i32* %38
br label %100
233: ; preds = %109
br label %234
234: ; preds = %233
%235 = load i32, i32* %37
%236 = add nsw i32 %235, 1
store i32 %236, i32* %37
br label %85
237: ; preds = %94
%238 = load float, float* %28
%239 = load float, float* %27
%240 = fcmp olt float %238, %239
br i1 %240, label %241, label %243
241: ; preds = %237
%242 = load float, float* %28
store float %242, float* %27
br label %243
243: ; preds = %241, %237
%244 = load i32, i32* %39
%245 = load i32, i32* %23
%246 = sub nsw i32 %244, %245
store i32 %246, i32* %45
br label %247
247: ; preds = %458, %243
%248 = load i32, i32* %45
%249 = load i32, i32* %39
%250 = load i32, i32* %23
%251 = add nsw i32 %249, %250
%252 = icmp sle i32 %248, %251
br i1 %252, label %253, label %257
253: ; preds = %247
%254 = load float, float* %27
%255 = fpext float %254 to double
%256 = fcmp ogt double %255, 0.000000e+00
br label %257
257: ; preds = %253, %247
%258 = phi i1 [ false, %247 ], [ %256, %253 ]
br i1 %258, label %259, label %461
259: ; preds = %257
%260 = load i32, i32* %45
%261 = icmp sge i32 %260, 0
br i1 %261, label %262, label %457
262: ; preds = %259
%263 = load i32, i32* %45
%264 = load i32, i32* %20
%265 = icmp slt i32 %263, %264
br i1 %265, label %266, label %457
266: ; preds = %262
%267 = load i32, i32* %40
%268 = load i32, i32* %23
%269 = sub nsw i32 %267, %268
store i32 %269, i32* %46
br label %270
270: ; preds = %453, %266
%271 = load i32, i32* %46
%272 = load i32, i32* %40
%273 = load i32, i32* %23
%274 = add nsw i32 %272, %273
%275 = icmp sle i32 %271, %274
br i1 %275, label %276, label %280
276: ; preds = %270
%277 = load float, float* %27
%278 = fpext float %277 to double
%279 = fcmp ogt double %278, 0.000000e+00
br label %280
280: ; preds = %276, %270
%281 = phi i1 [ false, %270 ], [ %279, %276 ]
br i1 %281, label %282, label %456
282: ; preds = %280
%283 = load i32, i32* %46
%284 = icmp sge i32 %283, 0
br i1 %284, label %285, label %452
285: ; preds = %282
%286 = load i32, i32* %46
%287 = load i32, i32* %21
%288 = icmp slt i32 %286, %287
br i1 %288, label %289, label %452
289: ; preds = %285
store float 0.000000e+00, float* %28
%290 = load i32, i32* %24
%291 = sub nsw i32 0, %290
%292 = sdiv i32 %291, 2
store i32 %292, i32* %37
br label %293
293: ; preds = %442, %289
%294 = load i32, i32* %37
%295 = load i32, i32* %24
%296 = sdiv i32 %295, 2
%297 = icmp sle i32 %294, %296
br i1 %297, label %298, label %302
298: ; preds = %293
%299 = load float, float* %28
%300 = load float, float* %27
%301 = fcmp olt float %299, %300
br label %302
302: ; preds = %298, %293
%303 = phi i1 [ false, %293 ], [ %301, %298 ]
br i1 %303, label %304, label %445
304: ; preds = %302
%305 = load i32, i32* %24
%306 = sub nsw i32 0, %305
%307 = sdiv i32 %306, 2
store i32 %307, i32* %38
br label %308
308: ; preds = %438, %304
%309 = load i32, i32* %38
%310 = load i32, i32* %24
%311 = sdiv i32 %310, 2
%312 = icmp sle i32 %309, %311
br i1 %312, label %313, label %317
313: ; preds = %308
%314 = load float, float* %28
%315 = load float, float* %27
%316 = fcmp olt float %314, %315
br label %317
317: ; preds = %313, %308
%318 = phi i1 [ false, %308 ], [ %316, %313 ]
br i1 %318, label %319, label %441
319: ; preds = %317
store i32 127, i32* %44
store i32 127, i32* %43
store i32 127, i32* %42
store i32 127, i32* %41
%320 = load i32, i32* %35
%321 = load i32, i32* %38
%322 = add nsw i32 %320, %321
%323 = icmp sge i32 %322, 0
br i1 %323, label %324, label %368
324: ; preds = %319
%325 = load i32, i32* %35
%326 = load i32, i32* %38
%327 = add nsw i32 %325, %326
%328 = load i32, i32* %16
%329 = icmp slt i32 %327, %328
br i1 %329, label %330, label %368
330: ; preds = %324
%331 = load i32, i32* %36
%332 = load i32, i32* %37
%333 = add nsw i32 %331, %332
%334 = icmp sge i32 %333, 0
br i1 %334, label %335, label %368
335: ; preds = %330
%336 = load i32, i32* %36
%337 = load i32, i32* %37
%338 = add nsw i32 %336, %337
%339 = load i32, i32* %17
%340 = icmp slt i32 %338, %339
br i1 %340, label %341, label %368
341: ; preds = %335
%342 = load i32**, i32*** %14
%343 = load i32, i32* %36
%344 = load i32, i32* %37
%345 = add nsw i32 %343, %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32*, i32** %342, i64 %346
%348 = load i32*, i32** %347
%349 = load i32, i32* %35
%350 = load i32, i32* %38
%351 = add nsw i32 %349, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32, i32* %348, i64 %352
%354 = load i32, i32* %353
store i32 %354, i32* %41
%355 = load i32**, i32*** %15
%356 = load i32, i32* %36
%357 = load i32, i32* %37
%358 = add nsw i32 %356, %357
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i32*, i32** %355, i64 %359
%361 = load i32*, i32** %360
%362 = load i32, i32* %35
%363 = load i32, i32* %38
%364 = add nsw i32 %362, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %361, i64 %365
%367 = load i32, i32* %366
store i32 %367, i32* %43
br label %368
368: ; preds = %341, %335, %330, %324, %319
%369 = load i32, i32* %45
%370 = load i32, i32* %38
%371 = add nsw i32 %369, %370
%372 = icmp sge i32 %371, 0
br i1 %372, label %373, label %417
373: ; preds = %368
%374 = load i32, i32* %45
%375 = load i32, i32* %38
%376 = add nsw i32 %374, %375
%377 = load i32, i32* %20
%378 = icmp slt i32 %376, %377
br i1 %378, label %379, label %417
379: ; preds = %373
%380 = load i32, i32* %46
%381 = load i32, i32* %37
%382 = add nsw i32 %380, %381
%383 = icmp sge i32 %382, 0
br i1 %383, label %384, label %417
384: ; preds = %379
%385 = load i32, i32* %46
%386 = load i32, i32* %37
%387 = add nsw i32 %385, %386
%388 = load i32, i32* %21
%389 = icmp slt i32 %387, %388
br i1 %389, label %390, label %417
390: ; preds = %384
%391 = load i32**, i32*** %18
%392 = load i32, i32* %46
%393 = load i32, i32* %37
%394 = add nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32*, i32** %391, i64 %395
%397 = load i32*, i32** %396
%398 = load i32, i32* %45
%399 = load i32, i32* %38
%400 = add nsw i32 %398, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds i32, i32* %397, i64 %401
%403 = load i32, i32* %402
store i32 %403, i32* %42
%404 = load i32**, i32*** %19
%405 = load i32, i32* %46
%406 = load i32, i32* %37
%407 = add nsw i32 %405, %406
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32*, i32** %404, i64 %408
%410 = load i32*, i32** %409
%411 = load i32, i32* %45
%412 = load i32, i32* %38
%413 = add nsw i32 %411, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i32, i32* %410, i64 %414
%416 = load i32, i32* %415
store i32 %416, i32* %44
br label %417
417: ; preds = %390, %384, %379, %373, %368
%418 = load i32, i32* %41
%419 = load i32, i32* %42
%420 = sub nsw i32 %418, %419
%421 = load i32, i32* %41
%422 = load i32, i32* %42
%423 = sub nsw i32 %421, %422
%424 = mul nsw i32 %420, %423
%425 = load i32, i32* %43
%426 = load i32, i32* %44
%427 = sub nsw i32 %425, %426
%428 = load i32, i32* %43
%429 = load i32, i32* %44
%430 = sub nsw i32 %428, %429
%431 = mul nsw i32 %427, %430
%432 = add nsw i32 %424, %431
%433 = sitofp i32 %432 to double
%434 = load float, float* %28
%435 = fpext float %434 to double
%436 = call double @llvm.fmuladd.f64(double %433, double 0x3EF0203040506071, double %435)
%437 = fptrunc double %436 to float
store float %437, float* %28
br label %438
438: ; preds = %417
%439 = load i32, i32* %38
%440 = add nsw i32 %439, 1
store i32 %440, i32* %38
br label %308
441: ; preds = %317
br label %442
442: ; preds = %441
%443 = load i32, i32* %37
%444 = add nsw i32 %443, 1
store i32 %444, i32* %37
br label %293
445: ; preds = %302
%446 = load float, float* %28
%447 = load float, float* %27
%448 = fcmp olt float %446, %447
br i1 %448, label %449, label %451
449: ; preds = %445
%450 = load float, float* %28
store float %450, float* %27
br label %451
451: ; preds = %449, %445
br label %452
452: ; preds = %451, %285, %282
br label %453
453: ; preds = %452
%454 = load i32, i32* %46
%455 = add nsw i32 %454, 1
store i32 %455, i32* %46
br label %270
456: ; preds = %280
br label %457
457: ; preds = %456, %262, %259
br label %458
458: ; preds = %457
%459 = load i32, i32* %45
%460 = add nsw i32 %459, 1
store i32 %460, i32* %45
br label %247
461: ; preds = %257
%462 = load float, float* %28
%463 = load float, float* %29
%464 = fcmp ogt float %462, %463
br i1 %464, label %465, label %467
465: ; preds = %461
%466 = load float, float* %28
store float %466, float* %29
br label %467
467: ; preds = %465, %461
%468 = load float, float* %28
%469 = load float**, float*** %22
%470 = load i32, i32* %36
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float*, float** %469, i64 %471
%473 = load float*, float** %472
%474 = load i32, i32* %35
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds float, float* %473, i64 %475
store float %468, float* %476
br label %477
477: ; preds = %467
%478 = load i32, i32* %26
%479 = add nsw i32 1, %478
%480 = load i32, i32* %36
%481 = add nsw i32 %480, %479
store i32 %481, i32* %36
br label %62
482: ; preds = %62
br label %483
483: ; preds = %482
%484 = load i32, i32* %26
%485 = add nsw i32 1, %484
%486 = load i32, i32* %35
%487 = add nsw i32 %486, %485
store i32 %487, i32* %35
br label %57
488: ; preds = %57
%489 = load float, float* %29
%490 = fcmp ogt float %489, 0.000000e+00
br i1 %490, label %491, label %888
491: ; preds = %488
%492 = load i32, i32* %26
%493 = icmp eq i32 %492, 1
br i1 %493, label %494, label %625
494: ; preds = %491
store i32 0, i32* %36
br label %495
495: ; preds = %556, %494
%496 = load i32, i32* %36
%497 = load i32, i32* %17
%498 = icmp slt i32 %496, %497
br i1 %498, label %499, label %559
499: ; preds = %495
store i32 1, i32* %35
br label %500
500: ; preds = %552, %499
%501 = load i32, i32* %35
%502 = load i32, i32* %16
%503 = icmp slt i32 %501, %502
br i1 %503, label %504, label %555
504: ; preds = %500
%505 = load i32, i32* %35
%506 = sub nsw i32 %505, 1
%507 = icmp sge i32 %506, 0
br i1 %507, label %508, label %519
508: ; preds = %504
%509 = load float**, float*** %22
%510 = load i32, i32* %36
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds float*, float** %509, i64 %511
%513 = load float*, float** %512
%514 = load i32, i32* %35
%515 = sub nsw i32 %514, 1
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds float, float* %513, i64 %516
%518 = load float, float* %517
br label %520
519: ; preds = %504
br label %520
520: ; preds = %519, %508
%521 = phi float [ %518, %508 ], [ 0.000000e+00, %519 ]
store float %521, float* %32
%522 = load i32, i32* %35
%523 = add nsw i32 %522, 1
%524 = load i32, i32* %16
%525 = icmp slt i32 %523, %524
br i1 %525, label %526, label %537
526: ; preds = %520
%527 = load float**, float*** %22
%528 = load i32, i32* %36
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds float*, float** %527, i64 %529
%531 = load float*, float** %530
%532 = load i32, i32* %35
%533 = add nsw i32 %532, 1
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds float, float* %531, i64 %534
%536 = load float, float* %535
br label %538
537: ; preds = %520
br label %538
538: ; preds = %537, %526
%539 = phi float [ %536, %526 ], [ 0.000000e+00, %537 ]
store float %539, float* %33
%540 = load float, float* %32
%541 = load float, float* %33
%542 = fadd float %540, %541
%543 = fdiv float %542, 2.000000e+00
%544 = load float**, float*** %22
%545 = load i32, i32* %36
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float*, float** %544, i64 %546
%548 = load float*, float** %547
%549 = load i32, i32* %35
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %548, i64 %550
store float %543, float* %551
br label %552
552: ; preds = %538
%553 = load i32, i32* %35
%554 = add nsw i32 %553, 2
store i32 %554, i32* %35
br label %500
555: ; preds = %500
br label %556
556: ; preds = %555
%557 = load i32, i32* %36
%558 = add nsw i32 %557, 2
store i32 %558, i32* %36
br label %495
559: ; preds = %495
store i32 1, i32* %36
br label %560
560: ; preds = %621, %559
%561 = load i32, i32* %36
%562 = load i32, i32* %17
%563 = icmp slt i32 %561, %562
br i1 %563, label %564, label %624
564: ; preds = %560
store i32 0, i32* %35
br label %565
565: ; preds = %617, %564
%566 = load i32, i32* %35
%567 = load i32, i32* %16
%568 = icmp slt i32 %566, %567
br i1 %568, label %569, label %620
569: ; preds = %565
%570 = load i32, i32* %36
%571 = sub nsw i32 %570, 1
%572 = icmp sge i32 %571, 0
br i1 %572, label %573, label %584
573: ; preds = %569
%574 = load float**, float*** %22
%575 = load i32, i32* %36
%576 = sub nsw i32 %575, 1
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds float*, float** %574, i64 %577
%579 = load float*, float** %578
%580 = load i32, i32* %35
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds float, float* %579, i64 %581
%583 = load float, float* %582
br label %585
584: ; preds = %569
br label %585
585: ; preds = %584, %573
%586 = phi float [ %583, %573 ], [ 0.000000e+00, %584 ]
store float %586, float* %32
%587 = load i32, i32* %36
%588 = add nsw i32 %587, 1
%589 = load i32, i32* %17
%590 = icmp slt i32 %588, %589
br i1 %590, label %591, label %602
591: ; preds = %585
%592 = load float**, float*** %22
%593 = load i32, i32* %36
%594 = add nsw i32 %593, 1
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds float*, float** %592, i64 %595
%597 = load float*, float** %596
%598 = load i32, i32* %35
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %597, i64 %599
%601 = load float, float* %600
br label %603
602: ; preds = %585
br label %603
603: ; preds = %602, %591
%604 = phi float [ %601, %591 ], [ 0.000000e+00, %602 ]
store float %604, float* %33
%605 = load float, float* %32
%606 = load float, float* %33
%607 = fadd float %605, %606
%608 = fdiv float %607, 2.000000e+00
%609 = load float**, float*** %22
%610 = load i32, i32* %36
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds float*, float** %609, i64 %611
%613 = load float*, float** %612
%614 = load i32, i32* %35
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds float, float* %613, i64 %615
store float %608, float* %616
br label %617
617: ; preds = %603
%618 = load i32, i32* %35
%619 = add nsw i32 %618, 1
store i32 %619, i32* %35
br label %565
620: ; preds = %565
br label %621
621: ; preds = %620
%622 = load i32, i32* %36
%623 = add nsw i32 %622, 2
store i32 %623, i32* %36
br label %560
624: ; preds = %560
br label %802
625: ; preds = %491
%626 = load i32, i32* %26
%627 = icmp eq i32 %626, 2
br i1 %627, label %628, label %801
628: ; preds = %625
store i32 0, i32* %36
br label %629
629: ; preds = %711, %628
%630 = load i32, i32* %36
%631 = load i32, i32* %17
%632 = icmp slt i32 %630, %631
br i1 %632, label %633, label %714
633: ; preds = %629
store i32 1, i32* %35
br label %634
634: ; preds = %707, %633
%635 = load i32, i32* %35
%636 = load i32, i32* %16
%637 = icmp slt i32 %635, %636
br i1 %637, label %638, label %710
638: ; preds = %634
%639 = load i32, i32* %35
%640 = sub nsw i32 %639, 1
%641 = icmp sge i32 %640, 0
br i1 %641, label %642, label %653
642: ; preds = %638
%643 = load float**, float*** %22
%644 = load i32, i32* %36
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds float*, float** %643, i64 %645
%647 = load float*, float** %646
%648 = load i32, i32* %35
%649 = sub nsw i32 %648, 1
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds float, float* %647, i64 %650
%652 = load float, float* %651
br label %654
653: ; preds = %638
br label %654
654: ; preds = %653, %642
%655 = phi float [ %652, %642 ], [ 0.000000e+00, %653 ]
store float %655, float* %32
%656 = load i32, i32* %35
%657 = add nsw i32 %656, 2
%658 = load i32, i32* %16
%659 = icmp slt i32 %657, %658
br i1 %659, label %660, label %671
660: ; preds = %654
%661 = load float**, float*** %22
%662 = load i32, i32* %36
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds float*, float** %661, i64 %663
%665 = load float*, float** %664
%666 = load i32, i32* %35
%667 = add nsw i32 %666, 2
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds float, float* %665, i64 %668
%670 = load float, float* %669
br label %672
671: ; preds = %654
br label %672
672: ; preds = %671, %660
%673 = phi float [ %670, %660 ], [ 0.000000e+00, %671 ]
store float %673, float* %33
%674 = load float, float* %33
%675 = load float, float* %32
%676 = fsub float %674, %675
%677 = fdiv float %676, 3.000000e+00
store float %677, float* %34
%678 = load float, float* %32
%679 = load float, float* %34
%680 = fadd float %678, %679
%681 = load float**, float*** %22
%682 = load i32, i32* %36
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds float*, float** %681, i64 %683
%685 = load float*, float** %684
%686 = load i32, i32* %35
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds float, float* %685, i64 %687
store float %680, float* %688
%689 = load i32, i32* %35
%690 = add nsw i32 %689, 1
%691 = load i32, i32* %16
%692 = icmp slt i32 %690, %691
br i1 %692, label %693, label %706
693: ; preds = %672
%694 = load float, float* %33
%695 = load float, float* %34
%696 = fsub float %694, %695
%697 = load float**, float*** %22
%698 = load i32, i32* %36
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds float*, float** %697, i64 %699
%701 = load float*, float** %700
%702 = load i32, i32* %35
%703 = add nsw i32 %702, 1
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds float, float* %701, i64 %704
store float %696, float* %705
br label %706
706: ; preds = %693, %672
br label %707
707: ; preds = %706
%708 = load i32, i32* %35
%709 = add nsw i32 %708, 3
store i32 %709, i32* %35
br label %634
710: ; preds = %634
br label %711
711: ; preds = %710
%712 = load i32, i32* %36
%713 = add nsw i32 %712, 3
store i32 %713, i32* %36
br label %629
714: ; preds = %629
store i32 1, i32* %36
br label %715
715: ; preds = %797, %714
%716 = load i32, i32* %36
%717 = load i32, i32* %17
%718 = icmp slt i32 %716, %717
br i1 %718, label %719, label %800
719: ; preds = %715
store i32 0, i32* %35
br label %720
720: ; preds = %793, %719
%721 = load i32, i32* %35
%722 = load i32, i32* %16
%723 = icmp slt i32 %721, %722
br i1 %723, label %724, label %796
724: ; preds = %720
%725 = load i32, i32* %36
%726 = sub nsw i32 %725, 1
%727 = icmp sge i32 %726, 0
br i1 %727, label %728, label %739
728: ; preds = %724
%729 = load float**, float*** %22
%730 = load i32, i32* %36
%731 = sub nsw i32 %730, 1
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds float*, float** %729, i64 %732
%734 = load float*, float** %733
%735 = load i32, i32* %35
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds float, float* %734, i64 %736
%738 = load float, float* %737
br label %740
739: ; preds = %724
br label %740
740: ; preds = %739, %728
%741 = phi float [ %738, %728 ], [ 0.000000e+00, %739 ]
store float %741, float* %32
%742 = load i32, i32* %36
%743 = add nsw i32 %742, 2
%744 = load i32, i32* %17
%745 = icmp slt i32 %743, %744
br i1 %745, label %746, label %757
746: ; preds = %740
%747 = load float**, float*** %22
%748 = load i32, i32* %36
%749 = add nsw i32 %748, 2
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float*, float** %747, i64 %750
%752 = load float*, float** %751
%753 = load i32, i32* %35
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds float, float* %752, i64 %754
%756 = load float, float* %755
br label %758
757: ; preds = %740
br label %758
758: ; preds = %757, %746
%759 = phi float [ %756, %746 ], [ 0.000000e+00, %757 ]
store float %759, float* %33
%760 = load float, float* %33
%761 = load float, float* %32
%762 = fsub float %760, %761
%763 = fdiv float %762, 3.000000e+00
store float %763, float* %34
%764 = load float, float* %32
%765 = load float, float* %34
%766 = fadd float %764, %765
%767 = load float**, float*** %22
%768 = load i32, i32* %36
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds float*, float** %767, i64 %769
%771 = load float*, float** %770
%772 = load i32, i32* %35
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds float, float* %771, i64 %773
store float %766, float* %774
%775 = load i32, i32* %36
%776 = add nsw i32 %775, 1
%777 = load i32, i32* %17
%778 = icmp slt i32 %776, %777
br i1 %778, label %779, label %792
779: ; preds = %758
%780 = load float, float* %33
%781 = load float, float* %34
%782 = fsub float %780, %781
%783 = load float**, float*** %22
%784 = load i32, i32* %36
%785 = add nsw i32 %784, 1
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float*, float** %783, i64 %786
%788 = load float*, float** %787
%789 = load i32, i32* %35
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds float, float* %788, i64 %790
store float %782, float* %791
br label %792
792: ; preds = %779, %758
br label %793
793: ; preds = %792
%794 = load i32, i32* %35
%795 = add nsw i32 %794, 1
store i32 %795, i32* %35
br label %720
796: ; preds = %720
br label %797
797: ; preds = %796
%798 = load i32, i32* %36
%799 = add nsw i32 %798, 3
store i32 %799, i32* %36
br label %715
800: ; preds = %715
br label %801
801: ; preds = %800, %625
br label %802
802: ; preds = %801, %624
store i32 0, i32* %46
br label %803
803: ; preds = %837, %802
%804 = load i32, i32* %46
%805 = load i32, i32* %17
%806 = icmp slt i32 %804, %805
br i1 %806, label %807, label %840
807: ; preds = %803
store i32 0, i32* %45
br label %808
808: ; preds = %833, %807
%809 = load i32, i32* %45
%810 = load i32, i32* %16
%811 = icmp slt i32 %809, %810
br i1 %811, label %812, label %836
812: ; preds = %808
%813 = load float**, float*** %22
%814 = load i32, i32* %46
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds float*, float** %813, i64 %815
%817 = load float*, float** %816
%818 = load i32, i32* %45
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds float, float* %817, i64 %819
%821 = load float, float* %820
%822 = load float, float* %29
%823 = fdiv float %821, %822
%824 = fmul float 2.550000e+02, %823
%825 = load float**, float*** %22
%826 = load i32, i32* %46
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds float*, float** %825, i64 %827
%829 = load float*, float** %828
%830 = load i32, i32* %45
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds float, float* %829, i64 %831
store float %824, float* %832
br label %833
833: ; preds = %812
%834 = load i32, i32* %45
%835 = add nsw i32 %834, 1
store i32 %835, i32* %45
br label %808
836: ; preds = %808
br label %837
837: ; preds = %836
%838 = load i32, i32* %46
%839 = add nsw i32 %838, 1
store i32 %839, i32* %46
br label %803
840: ; preds = %803
%841 = load i32*, i32** %25
%842 = icmp ne i32* %841, null
br i1 %842, label %843, label %883
843: ; preds = %840
%844 = load i32*, i32** %25
%845 = load i32, i32* %16
%846 = load i32, i32* %17
%847 = call i32 (i32*, i8*, ...) @fprintf(i32* %844, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 %845, i32 %846)
store i32 0, i32* %36
br label %848
848: ; preds = %877, %843
%849 = load i32, i32* %36
%850 = load i32, i32* %17
%851 = icmp slt i32 %849, %850
br i1 %851, label %852, label %880
852: ; preds = %848
store i32 0, i32* %35
br label %853
853: ; preds = %871, %852
%854 = load i32, i32* %35
%855 = load i32, i32* %16
%856 = icmp slt i32 %854, %855
br i1 %856, label %857, label %874
857: ; preds = %853
%858 = load i32*, i32** %25
%859 = load float**, float*** %22
%860 = load i32, i32* %36
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds float*, float** %859, i64 %861
%863 = load float*, float** %862
%864 = load i32, i32* %35
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds float, float* %863, i64 %865
%867 = load float, float* %866
%868 = fptosi float %867 to i32
%869 = sub nsw i32 255, %868
%870 = call i32 (i32*, i8*, ...) @fprintf(i32* %858, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %869)
br label %871
871: ; preds = %857
%872 = load i32, i32* %35
%873 = add nsw i32 %872, 1
store i32 %873, i32* %35
br label %853
874: ; preds = %853
%875 = load i32*, i32** %25
%876 = call i32 (i32*, i8*, ...) @fprintf(i32* %875, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %877
877: ; preds = %874
%878 = load i32, i32* %36
%879 = add nsw i32 %878, 1
store i32 %879, i32* %36
br label %848
880: ; preds = %848
%881 = load i32*, i32** %25
%882 = call i32 @fclose(i32* %881)
br label %883
883: ; preds = %880, %840
%884 = load float**, float*** %22
%885 = load i32, i32* %16
%886 = load i32, i32* %17
%887 = call i32 @otsu(float** %884, i32 %885, i32 %886, i32 255)
br label %888
888: ; preds = %883, %488
%889 = load float, float* %29
ret float %889
}

LLVM IR (-O2):
@FLT_MAX = global float 0.000000e+00
@.str = [14 x i8] c"P2\0A%d %d\0A255\0A\00"
@.str.1 = [4 x i8] c" %d\00"
define float @bidme(i32** nocapture %0, i32** nocapture %1, i32 %2, i32 %3, i32** nocapture %4, i32** nocapture %5, i32 %6, i32 %7, float** %8, i32 %9, i32 %10, i32* %11, i32 %12) {
%14 = sitofp i32 %6 to float
%15 = sitofp i32 %2 to float
%16 = fdiv float %14, %15
%17 = sitofp i32 %7 to float
%18 = sitofp i32 %3 to float
%19 = fdiv float %17, %18
%20 = icmp sgt i32 %2, 0
br i1 %20, label %21, label %577
21: ; preds = %13
%22 = icmp sgt i32 %3, 0
%23 = sdiv i32 %10, -2
%24 = sdiv i32 %10, 2
%25 = icmp sle i32 %23, %24
%26 = add i32 %12, 1
%27 = sext i32 %26 to i64
%28 = sext i32 %3 to i64
%29 = zext i32 %2 to i64
br label %30
30: ; preds = %21, %258
%31 = phi i64 [ 0, %21 ], [ %260, %258 ]
%32 = phi float [ 0.000000e+00, %21 ], [ %259, %258 ]
br i1 %22, label %33, label %258
33: ; preds = %30
%34 = trunc i64 %31 to i32
%35 = sitofp i32 %34 to float
%36 = fmul float %16, %35
%37 = fpext float %36 to double
%38 = fadd double %37, 5.000000e-01
%39 = fptosi double %38 to i32
%40 = sub nsw i32 %39, %9
%41 = add nsw i32 %39, %9
%42 = icmp sle i32 %40, %41
br label %43
43: ; preds = %33, %249
%44 = phi i64 [ 0, %33 ], [ %256, %249 ]
%45 = phi float [ %32, %33 ], [ %252, %249 ]
%46 = trunc i64 %44 to i32
%47 = sitofp i32 %46 to float
%48 = fmul float %19, %47
%49 = fpext float %48 to double
%50 = fadd double %49, 5.000000e-01
%51 = fptosi double %50 to i32
%52 = load float, float* @FLT_MAX
%53 = fcmp ogt float %52, 0.000000e+00
%54 = select i1 %25, i1 %53, i1 false
br i1 %54, label %55, label %128
55: ; preds = %43, %122
%56 = phi float [ %123, %122 ], [ 0.000000e+00, %43 ]
%57 = phi i32 [ %124, %122 ], [ %23, %43 ]
%58 = fcmp olt float %56, %52
br i1 %58, label %59, label %122
59: ; preds = %55
%60 = add nsw i32 %57, %46
%61 = icmp slt i32 %60, 0
%62 = icmp sge i32 %60, %3
%63 = zext i32 %60 to i64
%64 = getelementptr inbounds i32*, i32** %0, i64 %63
%65 = getelementptr inbounds i32*, i32** %1, i64 %63
%66 = add nsw i32 %57, %51
%67 = icmp slt i32 %66, 0
%68 = icmp sge i32 %66, %7
%69 = zext i32 %66 to i64
%70 = getelementptr inbounds i32*, i32** %4, i64 %69
%71 = getelementptr inbounds i32*, i32** %5, i64 %69
%72 = or i1 %61, %62
%73 = or i1 %67, %68
br label %74
74: ; preds = %59, %106
%75 = phi float [ %56, %59 ], [ %117, %106 ]
%76 = phi i32 [ %23, %59 ], [ %118, %106 ]
%77 = add nsw i32 %76, %34
%78 = icmp slt i32 %77, 0
%79 = icmp sge i32 %77, %2
%80 = or i1 %78, %79
%81 = select i1 %80, i1 true, i1 %72
br i1 %81, label %90, label %82
82: ; preds = %74
%83 = load i32*, i32** %64
%84 = zext i32 %77 to i64
%85 = getelementptr inbounds i32, i32* %83, i64 %84
%86 = load i32, i32* %85
%87 = load i32*, i32** %65
%88 = getelementptr inbounds i32, i32* %87, i64 %84
%89 = load i32, i32* %88
br label %90
90: ; preds = %74, %82
%91 = phi i32 [ %86, %82 ], [ 127, %74 ]
%92 = phi i32 [ %89, %82 ], [ 127, %74 ]
%93 = add nsw i32 %76, %39
%94 = icmp slt i32 %93, 0
%95 = icmp sge i32 %93, %6
%96 = or i1 %94, %95
%97 = select i1 %96, i1 true, i1 %73
br i1 %97, label %106, label %98
98: ; preds = %90
%99 = load i32*, i32** %70
%100 = zext i32 %93 to i64
%101 = getelementptr inbounds i32, i32* %99, i64 %100
%102 = load i32, i32* %101
%103 = load i32*, i32** %71
%104 = getelementptr inbounds i32, i32* %103, i64 %100
%105 = load i32, i32* %104
br label %106
106: ; preds = %90, %98
%107 = phi i32 [ %102, %98 ], [ 127, %90 ]
%108 = phi i32 [ %105, %98 ], [ 127, %90 ]
%109 = sub nsw i32 %91, %107
%110 = mul nsw i32 %109, %109
%111 = sub nsw i32 %92, %108
%112 = mul nsw i32 %111, %111
%113 = add nuw nsw i32 %112, %110
%114 = sitofp i32 %113 to double
%115 = fpext float %75 to double
%116 = tail call double @llvm.fmuladd.f64(double %114, double 0x3EF0203040506071, double %115)
%117 = fptrunc double %116 to float
%118 = add nsw i32 %76, 1
%119 = icmp slt i32 %76, %24
%120 = fcmp ogt float %52, %117
%121 = select i1 %119, i1 %120, i1 false
br i1 %121, label %74, label %122
122: ; preds = %106, %55
%123 = phi float [ %56, %55 ], [ %117, %106 ]
%124 = add nsw i32 %57, 1
%125 = icmp slt i32 %57, %24
%126 = fcmp olt float %123, %52
%127 = select i1 %125, i1 %126, i1 false
br i1 %127, label %55, label %128
128: ; preds = %122, %43
%129 = phi float [ 0.000000e+00, %43 ], [ %123, %122 ]
%130 = phi i1 [ %53, %43 ], [ %126, %122 ]
%131 = select i1 %130, float %129, float %52
%132 = fcmp ogt float %131, 0.000000e+00
%133 = select i1 %42, i1 %132, i1 false
br i1 %133, label %134, label %249
134: ; preds = %128
%135 = sub nsw i32 %51, %9
%136 = add nsw i32 %51, %9
%137 = icmp sle i32 %135, %136
br label %138
138: ; preds = %134, %242
%139 = phi i32 [ %40, %134 ], [ %245, %242 ]
%140 = phi float [ %131, %134 ], [ %244, %242 ]
%141 = phi float [ %129, %134 ], [ %243, %242 ]
%142 = icmp sgt i32 %139, -1
%143 = icmp slt i32 %139, %6
%144 = and i1 %142, %143
br i1 %144, label %145, label %242
145: ; preds = %138
%146 = fcmp ogt float %140, 0.000000e+00
%147 = select i1 %137, i1 %146, i1 false
br i1 %147, label %148, label %242
148: ; preds = %145, %235
%149 = phi i32 [ %238, %235 ], [ %135, %145 ]
%150 = phi float [ %237, %235 ], [ %140, %145 ]
%151 = phi float [ %236, %235 ], [ %141, %145 ]
%152 = icmp sgt i32 %149, -1
%153 = icmp slt i32 %149, %7
%154 = and i1 %152, %153
br i1 %154, label %155, label %235
155: ; preds = %148
%156 = fcmp ogt float %150, 0.000000e+00
%157 = select i1 %25, i1 %156, i1 false
br i1 %157, label %158, label %231
158: ; preds = %155, %225
%159 = phi float [ %226, %225 ], [ 0.000000e+00, %155 ]
%160 = phi i32 [ %227, %225 ], [ %23, %155 ]
%161 = fcmp olt float %159, %150
br i1 %161, label %162, label %225
162: ; preds = %158
%163 = add nsw i32 %160, %46
%164 = icmp slt i32 %163, 0
%165 = icmp sge i32 %163, %3
%166 = zext i32 %163 to i64
%167 = getelementptr inbounds i32*, i32** %0, i64 %166
%168 = getelementptr inbounds i32*, i32** %1, i64 %166
%169 = add nsw i32 %160, %149
%170 = icmp slt i32 %169, 0
%171 = icmp sge i32 %169, %7
%172 = zext i32 %169 to i64
%173 = getelementptr inbounds i32*, i32** %4, i64 %172
%174 = getelementptr inbounds i32*, i32** %5, i64 %172
%175 = or i1 %164, %165
%176 = or i1 %170, %171
br label %177
177: ; preds = %162, %209
%178 = phi float [ %159, %162 ], [ %220, %209 ]
%179 = phi i32 [ %23, %162 ], [ %221, %209 ]
%180 = add nsw i32 %179, %34
%181 = icmp slt i32 %180, 0
%182 = icmp sge i32 %180, %2
%183 = or i1 %181, %182
%184 = select i1 %183, i1 true, i1 %175
br i1 %184, label %193, label %185
185: ; preds = %177
%186 = load i32*, i32** %167
%187 = zext i32 %180 to i64
%188 = getelementptr inbounds i32, i32* %186, i64 %187
%189 = load i32, i32* %188
%190 = load i32*, i32** %168
%191 = getelementptr inbounds i32, i32* %190, i64 %187
%192 = load i32, i32* %191
br label %193
193: ; preds = %177, %185
%194 = phi i32 [ %189, %185 ], [ 127, %177 ]
%195 = phi i32 [ %192, %185 ], [ 127, %177 ]
%196 = add nsw i32 %179, %139
%197 = icmp slt i32 %196, 0
%198 = icmp sge i32 %196, %6
%199 = or i1 %197, %198
%200 = select i1 %199, i1 true, i1 %176
br i1 %200, label %209, label %201
201: ; preds = %193
%202 = load i32*, i32** %173
%203 = zext i32 %196 to i64
%204 = getelementptr inbounds i32, i32* %202, i64 %203
%205 = load i32, i32* %204
%206 = load i32*, i32** %174
%207 = getelementptr inbounds i32, i32* %206, i64 %203
%208 = load i32, i32* %207
br label %209
209: ; preds = %193, %201
%210 = phi i32 [ %205, %201 ], [ 127, %193 ]
%211 = phi i32 [ %208, %201 ], [ 127, %193 ]
%212 = sub nsw i32 %194, %210
%213 = mul nsw i32 %212, %212
%214 = sub nsw i32 %195, %211
%215 = mul nsw i32 %214, %214
%216 = add nuw nsw i32 %215, %213
%217 = sitofp i32 %216 to double
%218 = fpext float %178 to double
%219 = tail call double @llvm.fmuladd.f64(double %217, double 0x3EF0203040506071, double %218)
%220 = fptrunc double %219 to float
%221 = add nsw i32 %179, 1
%222 = icmp slt i32 %179, %24
%223 = fcmp ogt float %150, %220
%224 = select i1 %222, i1 %223, i1 false
br i1 %224, label %177, label %225
225: ; preds = %209, %158
%226 = phi float [ %159, %158 ], [ %220, %209 ]
%227 = add nsw i32 %160, 1
%228 = icmp slt i32 %160, %24
%229 = fcmp olt float %226, %150
%230 = select i1 %228, i1 %229, i1 false
br i1 %230, label %158, label %231
231: ; preds = %225, %155
%232 = phi float [ 0.000000e+00, %155 ], [ %226, %225 ]
%233 = phi i1 [ %156, %155 ], [ %229, %225 ]
%234 = select i1 %233, float %232, float %150
br label %235
235: ; preds = %231, %148
%236 = phi float [ %151, %148 ], [ %232, %231 ]
%237 = phi float [ %150, %148 ], [ %234, %231 ]
%238 = add nsw i32 %149, 1
%239 = icmp slt i32 %149, %136
%240 = fcmp ogt float %237, 0.000000e+00
%241 = select i1 %239, i1 %240, i1 false
br i1 %241, label %148, label %242
242: ; preds = %235, %145, %138
%243 = phi float [ %141, %138 ], [ %141, %145 ], [ %236, %235 ]
%244 = phi float [ %140, %138 ], [ %140, %145 ], [ %237, %235 ]
%245 = add nsw i32 %139, 1
%246 = icmp slt i32 %139, %41
%247 = fcmp ogt float %244, 0.000000e+00
%248 = select i1 %246, i1 %247, i1 false
br i1 %248, label %138, label %249
249: ; preds = %242, %128
%250 = phi float [ %129, %128 ], [ %243, %242 ]
%251 = fcmp ogt float %250, %45
%252 = select i1 %251, float %250, float %45
%253 = getelementptr inbounds float*, float** %8, i64 %44
%254 = load float*, float** %253
%255 = getelementptr inbounds float, float* %254, i64 %31
store float %250, float* %255
%256 = add i64 %44, %27
%257 = icmp slt i64 %256, %28
br i1 %257, label %43, label %258
258: ; preds = %249, %30
%259 = phi float [ %32, %30 ], [ %252, %249 ]
%260 = add i64 %31, %27
%261 = icmp slt i64 %260, %29
br i1 %261, label %30, label %262
262: ; preds = %258
%263 = fcmp ogt float %259, 0.000000e+00
br i1 %263, label %264, label %577
264: ; preds = %262
switch i32 %12, label %481 [
i32 1, label %271
i32 2, label %265
]
265: ; preds = %264
%266 = icmp sgt i32 %3, 0
br i1 %266, label %267, label %547
267: ; preds = %265
%268 = icmp sgt i32 %2, 1
%269 = sext i32 %2 to i64
%270 = zext i32 %3 to i64
br label %406
271: ; preds = %264
%272 = icmp sgt i32 %3, 0
br i1 %272, label %273, label %547
273: ; preds = %271
%274 = icmp sgt i32 %2, 1
%275 = sext i32 %2 to i64
%276 = zext i32 %3 to i64
%277 = add nsw i64 %275, -2
%278 = lshr i64 %277, 1
%279 = add nuw i64 %278, 1
%280 = and i64 %279, 1
%281 = icmp ult i64 %277, 2
%282 = and i64 %279, -2
%283 = icmp eq i64 %280, 0
br label %284
284: ; preds = %273, %346
%285 = phi i64 [ 0, %273 ], [ %347, %346 ]
br i1 %274, label %286, label %346
286: ; preds = %284
%287 = getelementptr inbounds float*, float** %8, i64 %285
%288 = load float*, float** %287
br i1 %281, label %330, label %297
289: ; preds = %346
%290 = icmp sgt i32 %3, 1
br i1 %290, label %291, label %481
291: ; preds = %289
%292 = zext i32 %3 to i64
%293 = and i64 %29, 1
%294 = icmp eq i32 %2, 1
%295 = and i64 %29, 4294967294
%296 = icmp eq i64 %293, 0
br label %349
297: ; preds = %286, %322
%298 = phi i64 [ %327, %322 ], [ 1, %286 ]
%299 = phi i64 [ %328, %322 ], [ 0, %286 ]
%300 = add nsw i64 %298, -1
%301 = getelementptr inbounds float, float* %288, i64 %300
%302 = load float, float* %301
%303 = add nuw nsw i64 %298, 1
%304 = icmp slt i64 %303, %275
br i1 %304, label %305, label %308
305: ; preds = %297
%306 = getelementptr inbounds float, float* %288, i64 %303
%307 = load float, float* %306
br label %308
308: ; preds = %297, %305
%309 = phi float [ %307, %305 ], [ 0.000000e+00, %297 ]
%310 = fadd float %302, %309
%311 = fmul float %310, 5.000000e-01
%312 = getelementptr inbounds float, float* %288, i64 %298
store float %311, float* %312
%313 = add nuw nsw i64 %298, 2
%314 = add nuw nsw i64 %298, 1
%315 = getelementptr inbounds float, float* %288, i64 %314
%316 = load float, float* %315
%317 = add nuw nsw i64 %298, 3
%318 = icmp slt i64 %317, %275
br i1 %318, label %319, label %322
319: ; preds = %308
%320 = getelementptr inbounds float, float* %288, i64 %317
%321 = load float, float* %320
br label %322
322: ; preds = %319, %308
%323 = phi float [ %321, %319 ], [ 0.000000e+00, %308 ]
%324 = fadd float %316, %323
%325 = fmul float %324, 5.000000e-01
%326 = getelementptr inbounds float, float* %288, i64 %313
store float %325, float* %326
%327 = add nuw nsw i64 %298, 4
%328 = add nuw nsw i64 %299, 2
%329 = icmp eq i64 %328, %282
br i1 %329, label %330, label %297
330: ; preds = %322, %286
%331 = phi i64 [ 1, %286 ], [ %327, %322 ]
br i1 %283, label %346, label %332
332: ; preds = %330
%333 = add nsw i64 %331, -1
%334 = getelementptr inbounds float, float* %288, i64 %333
%335 = load float, float* %334
%336 = add nuw nsw i64 %331, 1
%337 = icmp slt i64 %336, %275
br i1 %337, label %338, label %341
338: ; preds = %332
%339 = getelementptr inbounds float, float* %288, i64 %336
%340 = load float, float* %339
br label %341
341: ; preds = %338, %332
%342 = phi float [ %340, %338 ], [ 0.000000e+00, %332 ]
%343 = fadd float %335, %342
%344 = fmul float %343, 5.000000e-01
%345 = getelementptr inbounds float, float* %288, i64 %331
store float %344, float* %345
br label %346
346: ; preds = %341, %330, %284
%347 = add nuw nsw i64 %285, 2
%348 = icmp ult i64 %347, %276
br i1 %348, label %284, label %289
349: ; preds = %291, %403
%350 = phi i64 [ 1, %291 ], [ %404, %403 ]
br i1 %20, label %351, label %403
351: ; preds = %349
%352 = add nsw i64 %350, -1
%353 = getelementptr inbounds float*, float** %8, i64 %352
%354 = load float*, float** %353
%355 = add nuw nsw i64 %350, 1
%356 = icmp ult i64 %355, %292
%357 = getelementptr inbounds float*, float** %8, i64 %355
%358 = getelementptr inbounds float*, float** %8, i64 %350
%359 = load float*, float** %358
br i1 %294, label %389, label %360
360: ; preds = %351, %381
%361 = phi i64 [ %386, %381 ], [ 0, %351 ]
%362 = phi i64 [ %387, %381 ], [ 0, %351 ]
%363 = getelementptr inbounds float, float* %354, i64 %361
%364 = load float, float* %363
br i1 %356, label %365, label %369
365: ; preds = %360
%366 = load float*, float** %357
%367 = getelementptr inbounds float, float* %366, i64 %361
%368 = load float, float* %367
br label %369
369: ; preds = %360, %365
%370 = phi float [ %368, %365 ], [ 0.000000e+00, %360 ]
%371 = fadd float %364, %370
%372 = fmul float %371, 5.000000e-01
%373 = getelementptr inbounds float, float* %359, i64 %361
store float %372, float* %373
%374 = or i64 %361, 1
%375 = getelementptr inbounds float, float* %354, i64 %374
%376 = load float, float* %375
br i1 %356, label %377, label %381
377: ; preds = %369
%378 = load float*, float** %357
%379 = getelementptr inbounds float, float* %378, i64 %374
%380 = load float, float* %379
br label %381
381: ; preds = %377, %369
%382 = phi float [ %380, %377 ], [ 0.000000e+00, %369 ]
%383 = fadd float %376, %382
%384 = fmul float %383, 5.000000e-01
%385 = getelementptr inbounds float, float* %359, i64 %374
store float %384, float* %385
%386 = add nuw nsw i64 %361, 2
%387 = add i64 %362, 2
%388 = icmp eq i64 %387, %295
br i1 %388, label %389, label %360
389: ; preds = %381, %351
%390 = phi i64 [ 0, %351 ], [ %386, %381 ]
br i1 %296, label %403, label %391
391: ; preds = %389
%392 = getelementptr inbounds float, float* %354, i64 %390
%393 = load float, float* %392
br i1 %356, label %394, label %398
394: ; preds = %391
%395 = load float*, float** %357
%396 = getelementptr inbounds float, float* %395, i64 %390
%397 = load float, float* %396
br label %398
398: ; preds = %394, %391
%399 = phi float [ %397, %394 ], [ 0.000000e+00, %391 ]
%400 = fadd float %393, %399
%401 = fmul float %400, 5.000000e-01
%402 = getelementptr inbounds float, float* %359, i64 %390
store float %401, float* %402
br label %403
403: ; preds = %398, %389, %349
%404 = add nuw nsw i64 %350, 2
%405 = icmp ult i64 %404, %292
br i1 %405, label %349, label %481
406: ; preds = %267, %440
%407 = phi i64 [ 0, %267 ], [ %441, %440 ]
br i1 %268, label %408, label %440
408: ; preds = %406
%409 = getelementptr inbounds float*, float** %8, i64 %407
%410 = load float*, float** %409
br label %416
411: ; preds = %440
%412 = icmp sgt i32 %3, 1
br i1 %412, label %413, label %481
413: ; preds = %411
%414 = zext i32 %3 to i64
%415 = zext i32 %2 to i64
br label %443
416: ; preds = %408, %437
%417 = phi i64 [ 1, %408 ], [ %438, %437 ]
%418 = add nsw i64 %417, -1
%419 = getelementptr inbounds float, float* %410, i64 %418
%420 = load float, float* %419
%421 = add nuw nsw i64 %417, 2
%422 = icmp slt i64 %421, %269
br i1 %422, label %423, label %426
423: ; preds = %416
%424 = getelementptr inbounds float, float* %410, i64 %421
%425 = load float, float* %424
br label %426
426: ; preds = %416, %423
%427 = phi float [ %425, %423 ], [ 0.000000e+00, %416 ]
%428 = fsub float %427, %420
%429 = fdiv float %428, 3.000000e+00
%430 = fadd float %420, %429
%431 = getelementptr inbounds float, float* %410, i64 %417
store float %430, float* %431
%432 = add nuw nsw i64 %417, 1
%433 = icmp slt i64 %432, %269
br i1 %433, label %434, label %437
434: ; preds = %426
%435 = fsub float %427, %429
%436 = getelementptr inbounds float, float* %410, i64 %432
store float %435, float* %436
br label %437
437: ; preds = %426, %434
%438 = add nuw nsw i64 %417, 3
%439 = icmp slt i64 %438, %269
br i1 %439, label %416, label %440
440: ; preds = %437, %406
%441 = add nuw nsw i64 %407, 3
%442 = icmp ult i64 %441, %270
br i1 %442, label %406, label %411
443: ; preds = %413, %478
%444 = phi i64 [ 1, %413 ], [ %479, %478 ]
br i1 %20, label %445, label %478
445: ; preds = %443
%446 = add nsw i64 %444, -1
%447 = getelementptr inbounds float*, float** %8, i64 %446
%448 = load float*, float** %447
%449 = add nuw nsw i64 %444, 2
%450 = icmp ult i64 %449, %414
%451 = getelementptr inbounds float*, float** %8, i64 %449
%452 = getelementptr inbounds float*, float** %8, i64 %444
%453 = load float*, float** %452
%454 = add nuw nsw i64 %444, 1
%455 = icmp ult i64 %454, %414
%456 = getelementptr inbounds float*, float** %8, i64 %454
br label %457
457: ; preds = %445, %475
%458 = phi i64 [ 0, %445 ], [ %476, %475 ]
%459 = getelementptr inbounds float, float* %448, i64 %458
%460 = load float, float* %459
br i1 %450, label %461, label %465
461: ; preds = %457
%462 = load float*, float** %451
%463 = getelementptr inbounds float, float* %462, i64 %458
%464 = load float, float* %463
br label %465
465: ; preds = %457, %461
%466 = phi float [ %464, %461 ], [ 0.000000e+00, %457 ]
%467 = fsub float %466, %460
%468 = fdiv float %467, 3.000000e+00
%469 = fadd float %460, %468
%470 = getelementptr inbounds float, float* %453, i64 %458
store float %469, float* %470
br i1 %455, label %471, label %475
471: ; preds = %465
%472 = fsub float %466, %468
%473 = load float*, float** %456
%474 = getelementptr inbounds float, float* %473, i64 %458
store float %472, float* %474
br label %475
475: ; preds = %465, %471
%476 = add nuw nsw i64 %458, 1
%477 = icmp eq i64 %476, %415
br i1 %477, label %478, label %457
478: ; preds = %475, %443
%479 = add nuw nsw i64 %444, 3
%480 = icmp ult i64 %479, %414
br i1 %480, label %443, label %481
481: ; preds = %478, %403, %411, %289, %264
%482 = icmp sgt i32 %3, 0
br i1 %482, label %483, label %547
483: ; preds = %481
%484 = zext i32 %3 to i64
%485 = zext i32 %2 to i64
%486 = and i64 %29, 4294967292
%487 = add nsw i64 %486, -4
%488 = lshr exact i64 %487, 2
%489 = add nuw nsw i64 %488, 1
%490 = icmp ult i32 %2, 4
%491 = and i64 %29, 4294967292
%492 = insertelement <4 x float> poison, float %259, i64 0
%493 = shufflevector <4 x float> %492, <4 x float> poison, <4 x i32> zeroinitializer
%494 = and i64 %489, 1
%495 = icmp eq i64 %487, 0
%496 = and i64 %489, 9223372036854775806
%497 = icmp eq i64 %494, 0
%498 = icmp eq i64 %491, %29
br label %499
499: ; preds = %483, %544
%500 = phi i64 [ 0, %483 ], [ %545, %544 ]
br i1 %20, label %501, label %544
501: ; preds = %499
%502 = getelementptr inbounds float*, float** %8, i64 %500
%503 = load float*, float** %502
br i1 %490, label %534, label %504
504: ; preds = %501
br i1 %495, label %524, label %505
505: ; preds = %504, %505
%506 = phi i64 [ %521, %505 ], [ 0, %504 ]
%507 = phi i64 [ %522, %505 ], [ 0, %504 ]
%508 = getelementptr inbounds float, float* %503, i64 %506
%509 = bitcast float* %508 to <4 x float>*
%510 = load <4 x float>, <4 x float>* %509
%511 = fdiv <4 x float> %510, %493
%512 = fmul <4 x float> %511, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%513 = bitcast float* %508 to <4 x float>*
store <4 x float> %512, <4 x float>* %513
%514 = or i64 %506, 4
%515 = getelementptr inbounds float, float* %503, i64 %514
%516 = bitcast float* %515 to <4 x float>*
%517 = load <4 x float>, <4 x float>* %516
%518 = fdiv <4 x float> %517, %493
%519 = fmul <4 x float> %518, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%520 = bitcast float* %515 to <4 x float>*
store <4 x float> %519, <4 x float>* %520
%521 = add nuw i64 %506, 8
%522 = add i64 %507, 2
%523 = icmp eq i64 %522, %496
br i1 %523, label %524, label %505
524: ; preds = %505, %504
%525 = phi i64 [ 0, %504 ], [ %521, %505 ]
br i1 %497, label %533, label %526
526: ; preds = %524
%527 = getelementptr inbounds float, float* %503, i64 %525
%528 = bitcast float* %527 to <4 x float>*
%529 = load <4 x float>, <4 x float>* %528
%530 = fdiv <4 x float> %529, %493
%531 = fmul <4 x float> %530, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%532 = bitcast float* %527 to <4 x float>*
store <4 x float> %531, <4 x float>* %532
br label %533
533: ; preds = %524, %526
br i1 %498, label %544, label %534
534: ; preds = %501, %533
%535 = phi i64 [ 0, %501 ], [ %491, %533 ]
br label %536
536: ; preds = %534, %536
%537 = phi i64 [ %542, %536 ], [ %535, %534 ]
%538 = getelementptr inbounds float, float* %503, i64 %537
%539 = load float, float* %538
%540 = fdiv float %539, %259
%541 = fmul float %540, 2.550000e+02
store float %541, float* %538
%542 = add nuw nsw i64 %537, 1
%543 = icmp eq i64 %542, %485
br i1 %543, label %544, label %536
544: ; preds = %536, %533, %499
%545 = add nuw nsw i64 %500, 1
%546 = icmp eq i64 %545, %484
br i1 %546, label %547, label %499
547: ; preds = %544, %271, %265, %481
%548 = phi i1 [ false, %481 ], [ false, %265 ], [ false, %271 ], [ %482, %544 ]
%549 = icmp eq i32* %11, null
br i1 %549, label %575, label %550
550: ; preds = %547
%551 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %11, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 %2, i32 %3)
br i1 %548, label %552, label %573
552: ; preds = %550
%553 = zext i32 %3 to i64
%554 = zext i32 %2 to i64
br label %555
555: ; preds = %552, %569
%556 = phi i64 [ 0, %552 ], [ %571, %569 ]
br i1 %20, label %557, label %569
557: ; preds = %555
%558 = getelementptr inbounds float*, float** %8, i64 %556
br label %559
559: ; preds = %557, %559
%560 = phi i64 [ 0, %557 ], [ %567, %559 ]
%561 = load float*, float** %558
%562 = getelementptr inbounds float, float* %561, i64 %560
%563 = load float, float* %562
%564 = fptosi float %563 to i32
%565 = sub nsw i32 255, %564
%566 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %11, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %565)
%567 = add nuw nsw i64 %560, 1
%568 = icmp eq i64 %567, %554
br i1 %568, label %569, label %559
569: ; preds = %559, %555
%570 = tail call i32 @fputc(i32 10, i32* %11)
%571 = add nuw nsw i64 %556, 1
%572 = icmp eq i64 %571, %553
br i1 %572, label %573, label %555
573: ; preds = %569, %550
%574 = tail call i32 @fclose(i32* %11)
br label %575
575: ; preds = %573, %547
%576 = tail call i32 @otsu(float** %8, i32 %2, i32 %3, i32 255)
br label %577
577: ; preds = %13, %575, %262
%578 = phi float [ %259, %575 ], [ %259, %262 ], [ 0.000000e+00, %13 ]
ret float %578
}