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

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ stderr;
int otsu(unsigned char *image, int rows, int cols, int x0, int y0, int dx,
         int dy, int vvv) {
  unsigned char *np;
  unsigned char op1, op2;
  int maxc = 0;
  int thresholdValue = 1;
  int ihist[256];
  int chist[256];
  int i, j, k;
  int is, i1, i2, ns, n1, n2, gmin, gmax;
  double m1, m2, sum, csum, fmax, sb;
  memset(ihist, 0, sizeof(ihist));
  memset(chist, 0, sizeof(chist));
  op1 = op2 = 0;
  gmin = 255;
  gmax = 0;
  k = dy / 512 + 1;
  for (i = 0; i < dy; i += k) {
    np = &image[(y0 + i) * cols + x0];
    for (j = 0; j < dx; j++) {
      ihist[*np]++;
      if (*np > gmax)
        gmax = *np;
      if (*np < gmin)
        gmin = *np;
      if (((*np - op1 < 0) ? -(*np - op1) : *np - op1) > maxc)
        maxc = ((*np - op1 < 0) ? -(*np - op1) : *np - op1);
      if (((*np - op2 < 0) ? -(*np - op2) : *np - op2) > maxc)
        maxc = ((*np - op2 < 0) ? -(*np - op2) : *np - op2);
      op2 = op1;
      op1 = *np;
      np++;
    }
  }
  for (i = 0; i < dy; i += k) {
    np = &image[(y0 + i) * cols + x0];
    for (j = 0; j < dx; j++) {
      if (((*np - op1 < 0) ? -(*np - op1) : *np - op1) > maxc / 4 ||
          ((*np - op2 < 0) ? -(*np - op2) : *np - op2) > maxc / 4)
        chist[*np]++;
      op2 = op1;
      op1 = *np;
      np++;
    }
  }
  sum = csum = 0.0;
  ns = 0;
  is = 0;
  for (k = 0; k <= 255; k++) {
    sum += (double)k * (double)chist[k];
    ns += chist[k];
    is += ihist[k];
  }
  if (!ns) {
    fprintf(stderr, "NOT NORMAL, thresholdValue = 160\n");
    return (160);
  }
  if ((vvv & 1))
    fprintf(stderr, "# threshold: value ihist chist mass_dipol_moment\n");
  fmax = -1.0;
  n1 = 0;
  for (k = 0; k < 255; k++) {
    n1 += chist[k];
    if (!n1)
      continue;
    n2 = ns - n1;
    if (n2 == 0)
      break;
    csum += (double)k * chist[k];
    m1 = csum / n1;
    m2 = (sum - csum) / n2;
    sb = (double)n1 * (double)n2 * (m2 - m1);
    if (sb > fmax) {
      fmax = sb;
      thresholdValue = k + 1;
    }
    if ((vvv & 1) && ihist[k])
      fprintf(stderr, "# threshold: %3d %6d %6d %8.2f\n", k, ihist[k], chist[k],
              sb / (dx * dy));
  }
  i1 = 0;
  for (k = 0; k < thresholdValue; k++) {
    i1 += ihist[k];
  }
  i2 = is - i1;
  if (thresholdValue > gmax) {
    fprintf(stderr, "# threshold: Value >gmax\n");
    thresholdValue = gmax;
  }
  if (thresholdValue <= gmin) {
    fprintf(stderr, "# threshold: Value<=gmin\n");
    thresholdValue = gmin + 1;
  }
  if (vvv & 1)
    fprintf(stderr,
            "# threshold: Value = %d gmin=%d gmax=%d cmax=%d"
            " i= %d %d\n",
            thresholdValue, gmin, gmax, maxc, i1, i2);
  if (i1 >= 4 * i2) {
    if (vvv & 1)
      fprintf(stderr, "# threshold: invert the image\n");
    for (i = 0; i < dy; i++) {
      np = &image[(y0 + i) * cols + x0];
      for (j = 0; j < dx; j++) {
        *np = 255 - *np;
        np++;
      }
    }
    thresholdValue = 255 - thresholdValue + 1;
  }
  return (thresholdValue);
}


x86 assembly (clang, -O0):
<otsu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8d0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
lea    -0x440(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
lea    -0x840(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
movb   $0x0,-0x32(%rbp)
movb   $0x0,-0x31(%rbp)
movl   $0xff,-0x868(%rbp)
movl   $0x0,-0x86c(%rbp)
mov    0x10(%rbp),%eax
mov    $0x200,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
movl   $0x0,-0x844(%rbp)
mov    -0x844(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13e1 <otsu+0x2c1>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x844(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x848(%rbp)
mov    -0x848(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13c5 <otsu+0x2a5>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    -0x440(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x440(%rbp,%rax,4)
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    -0x86c(%rbp),%eax
jle    1232 <otsu+0x112>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x86c(%rbp)
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    -0x868(%rbp),%eax
jge    1252 <otsu+0x132>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x868(%rbp)
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    1284 <otsu+0x164>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x31(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8a4(%rbp)
jmp    1297 <otsu+0x177>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8a4(%rbp)
mov    -0x8a4(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    12f4 <otsu+0x1d4>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    12d8 <otsu+0x1b8>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x31(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8a8(%rbp)
jmp    12eb <otsu+0x1cb>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8a8(%rbp)
mov    -0x8a8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    1326 <otsu+0x206>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x32(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8ac(%rbp)
jmp    1339 <otsu+0x219>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8ac(%rbp)
mov    -0x8ac(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1396 <otsu+0x276>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    137a <otsu+0x25a>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x32(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8b0(%rbp)
jmp    138d <otsu+0x26d>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8b0(%rbp)
mov    -0x8b0(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x31(%rbp),%al
mov    %al,-0x32(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x31(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x848(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x848(%rbp)
jmp    11eb <otsu+0xcb>
jmp    13ca <otsu+0x2aa>
mov    -0x84c(%rbp),%eax
add    -0x844(%rbp),%eax
mov    %eax,-0x844(%rbp)
jmp    11b4 <otsu+0x94>
movl   $0x0,-0x844(%rbp)
mov    -0x844(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    156c <otsu+0x44c>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x844(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x848(%rbp)
mov    -0x848(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1550 <otsu+0x430>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    1463 <otsu+0x343>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x31(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8b4(%rbp)
jmp    1476 <otsu+0x356>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x31(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8b4(%rbp)
mov    -0x8b4(%rbp),%eax
mov    %eax,-0x8b8(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8b8(%rbp),%eax
cmp    %ecx,%eax
jg     1509 <otsu+0x3e9>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jge    14cf <otsu+0x3af>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x32(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x8bc(%rbp)
jmp    14e2 <otsu+0x3c2>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x32(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8bc(%rbp)
mov    -0x8bc(%rbp),%eax
mov    %eax,-0x8c0(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c0(%rbp),%eax
cmp    %ecx,%eax
jle    1521 <otsu+0x401>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
mov    -0x840(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x840(%rbp,%rax,4)
mov    -0x31(%rbp),%al
mov    %al,-0x32(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x31(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x848(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x848(%rbp)
jmp    1422 <otsu+0x302>
jmp    1555 <otsu+0x435>
mov    -0x84c(%rbp),%eax
add    -0x844(%rbp),%eax
mov    %eax,-0x844(%rbp)
jmp    13eb <otsu+0x2cb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x890(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x888(%rbp)
ff
movl   $0x0,-0x85c(%rbp)
movl   $0x0,-0x850(%rbp)
movl   $0x0,-0x84c(%rbp)
cmpl   $0xff,-0x84c(%rbp)
jg     1628 <otsu+0x508>
cvtsi2sdl -0x84c(%rbp),%xmm0
ff
movslq -0x84c(%rbp),%rax
cvtsi2sdl -0x840(%rbp,%rax,4),%xmm2
ff ff
movsd  -0x888(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x888(%rbp)
ff
movslq -0x84c(%rbp),%rax
mov    -0x840(%rbp,%rax,4),%eax
add    -0x85c(%rbp),%eax
mov    %eax,-0x85c(%rbp)
movslq -0x84c(%rbp),%rax
mov    -0x440(%rbp,%rax,4),%eax
add    -0x850(%rbp),%eax
mov    %eax,-0x850(%rbp)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
jmp    15a0 <otsu+0x480>
cmpl   $0x0,-0x85c(%rbp)
jne    1658 <otsu+0x538>
mov    0x29a4(%rip),%rax
mov    (%rax),%edi
lea    0x9c3(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0xa0,-0x4(%rbp)
jmp    1a65 <otsu+0x945>
mov    0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     167e <otsu+0x55e>
mov    0x2972(%rip),%rax
mov    (%rax),%edi
lea    0x9b3(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movsd  0x97a(%rip),%xmm0
movsd  %xmm0,-0x898(%rbp)
ff
movl   $0x0,-0x860(%rbp)
movl   $0x0,-0x84c(%rbp)
cmpl   $0xff,-0x84c(%rbp)
jge    1862 <otsu+0x742>
movslq -0x84c(%rbp),%rax
mov    -0x840(%rbp,%rax,4),%eax
add    -0x860(%rbp),%eax
mov    %eax,-0x860(%rbp)
cmpl   $0x0,-0x860(%rbp)
jne    16de <otsu+0x5be>
jmp    184e <otsu+0x72e>
mov    -0x85c(%rbp),%eax
sub    -0x860(%rbp),%eax
mov    %eax,-0x864(%rbp)
cmpl   $0x0,-0x864(%rbp)
jne    1702 <otsu+0x5e2>
jmp    1862 <otsu+0x742>
cvtsi2sdl -0x84c(%rbp),%xmm0
ff
movslq -0x84c(%rbp),%rax
cvtsi2sdl -0x840(%rbp,%rax,4),%xmm2
ff ff
movsd  -0x890(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x890(%rbp)
ff
movsd  -0x890(%rbp),%xmm0
ff
cvtsi2sdl -0x860(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x878(%rbp)
ff
movsd  -0x888(%rbp),%xmm0
ff
subsd  -0x890(%rbp),%xmm0
ff
cvtsi2sdl -0x864(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x880(%rbp)
ff
cvtsi2sdl -0x860(%rbp),%xmm0
ff
cvtsi2sdl -0x864(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x880(%rbp),%xmm1
ff
subsd  -0x878(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x8a0(%rbp)
ff
movsd  -0x8a0(%rbp),%xmm0
ff
ucomisd -0x898(%rbp),%xmm0
ff
jbe    17d4 <otsu+0x6b4>
movsd  -0x8a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x898(%rbp)
ff
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1849 <otsu+0x729>
movslq -0x84c(%rbp),%rax
cmpl   $0x0,-0x440(%rbp,%rax,4)
je     1849 <otsu+0x729>
mov    0x27e1(%rip),%rax
mov    (%rax),%edi
mov    -0x84c(%rbp),%edx
movslq -0x84c(%rbp),%rax
mov    -0x440(%rbp,%rax,4),%ecx
movslq -0x84c(%rbp),%rax
mov    -0x840(%rbp,%rax,4),%r8d
ff
movsd  -0x8a0(%rbp),%xmm0
ff
mov    -0x24(%rbp),%eax
imul   0x10(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
lea    0x81a(%rip),%rsi
mov    $0x1,%al
call   1040 <fprintf@plt>
jmp    184e <otsu+0x72e>
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
jmp    16a2 <otsu+0x582>
movl   $0x0,-0x854(%rbp)
movl   $0x0,-0x84c(%rbp)
mov    -0x84c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    18b3 <otsu+0x793>
movslq -0x84c(%rbp),%rax
mov    -0x440(%rbp,%rax,4),%eax
add    -0x854(%rbp),%eax
mov    %eax,-0x854(%rbp)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
jmp    1876 <otsu+0x756>
mov    -0x850(%rbp),%eax
sub    -0x854(%rbp),%eax
mov    %eax,-0x858(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x86c(%rbp),%eax
jle    18f4 <otsu+0x7d4>
mov    0x2705(%rip),%rax
mov    (%rax),%edi
lea    0x798(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x86c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x868(%rbp),%eax
jg     1926 <otsu+0x806>
mov    0x26d6(%rip),%rax
mov    (%rax),%edi
lea    0x783(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x868(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1975 <otsu+0x855>
mov    0x26a4(%rip),%rax
mov    (%rax),%edi
mov    -0x3c(%rbp),%edx
mov    -0x868(%rbp),%ecx
mov    -0x86c(%rbp),%r8d
mov    -0x38(%rbp),%r9d
mov    -0x854(%rbp),%r10d
mov    -0x858(%rbp),%eax
lea    0x74a(%rip),%rsi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x854(%rbp),%eax
mov    -0x858(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jl     1a5f <otsu+0x93f>
mov    0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     19b2 <otsu+0x892>
mov    0x263e(%rip),%rax
mov    (%rax),%edi
lea    0x73f(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0x844(%rbp)
mov    -0x844(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a51 <otsu+0x931>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x844(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x848(%rbp)
mov    -0x848(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1a38 <otsu+0x918>
mov    -0x30(%rbp),%rax
movzbl (%rax),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x848(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x848(%rbp)
jmp    19f3 <otsu+0x8d3>
jmp    1a3d <otsu+0x91d>
mov    -0x844(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x844(%rbp)
jmp    19bc <otsu+0x89c>
mov    $0xff,%eax
sub    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x8d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<otsu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x868,%rsp
mov    %r9d,%r13d
mov    %r8d,%ebx
mov    %ecx,%r12d
mov    %edx,%ebp
mov    %rdi,0x30(%rsp)
mov    0x8a0(%rsp),%r15d
lea    0x60(%rsp),%rdi
xor    %r14d,%r14d
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
lea    0x460(%rsp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
mov    %r13,%r10
lea    0x1ff(%r15),%eax
test   %r15d,%r15d
cmovns %r15d,%eax
mov    %r13,0x8(%rsp)
mov    %r12d,0x4c(%rsp)
mov    %ebx,0x48(%rsp)
mov    %ebp,0x44(%rsp)
jle    130c <otsu+0x1ec>
sar    $0x9,%eax
add    $0x1,%eax
movslq %eax,%rcx
movslq %ebx,%r13
movslq %ebp,%rdx
movslq %r12d,%rax
mov    %r15d,%esi
mov    %rsi,0x10(%rsp)
imul   %rdx,%r13
add    %rax,%r13
mov    0x30(%rsp),%rax
lea    (%rax,%r13,1),%r8
mov    %rcx,(%rsp)
imul   %rcx,%rdx
mov    %rdx,0x20(%rsp)
mov    %r10d,%r9d
mov    $0xff,%ebp
xor    %r11d,%r11d
xor    %ebx,%ebx
xor    %r15d,%r15d
xor    %esi,%esi
xor    %r12d,%r12d
jmp    1200 <otsu+0xe0>
nopl   0x0(%rax,%rax,1)
add    (%rsp),%r11
add    0x20(%rsp),%r8
cmp    0x10(%rsp),%r11
jge    1263 <otsu+0x143>
test   %r10d,%r10d
jle    11f0 <otsu+0xd0>
xor    %edx,%edx
mov    %esi,%ecx
nopl   0x0(%rax)
mov    %ebx,%esi
movzbl (%r8,%rdx,1),%ebx
addl   $0x1,0x60(%rsp,%rbx,4)
cmp    %ebx,%r15d
cmovl  %ebx,%r15d
cmp    %ebx,%ebp
cmovg  %ebx,%ebp
movzbl %sil,%edi
mov    %ebx,%eax
sub    %edi,%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
cmp    %r12d,%edi
cmovle %r12d,%edi
movzbl %cl,%eax
mov    %ebx,%ecx
sub    %eax,%ecx
mov    %ecx,%r12d
neg    %r12d
cmovs  %ecx,%r12d
cmp    %edi,%r12d
cmovbe %edi,%r12d
add    $0x1,%rdx
mov    %esi,%ecx
cmp    %edx,%r9d
jne    1210 <otsu+0xf0>
jmp    11f0 <otsu+0xd0>
mov    0x8a0(%rsp),%eax
test   %eax,%eax
jle    1317 <otsu+0x1f7>
lea    0x3(%r12),%eax
test   %r12d,%r12d
cmovns %r12d,%eax
sar    $0x2,%eax
add    0x30(%rsp),%r13
xor    %r11d,%r11d
jmp    12a9 <otsu+0x189>
nopl   0x0(%rax,%rax,1)
mov    %esi,%edx
add    (%rsp),%r11
add    0x20(%rsp),%r13
mov    %edx,%esi
cmp    0x10(%rsp),%r11
mov    0x8(%rsp),%r10
jge    1317 <otsu+0x1f7>
test   %r10d,%r10d
jle    1290 <otsu+0x170>
xor    %ecx,%ecx
jmp    12d4 <otsu+0x1b4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addl   $0x1,0x460(%rsp,%r8,4)
add    $0x1,%rcx
mov    %edx,%esi
cmp    %ecx,%r9d
je     1292 <otsu+0x172>
mov    %ebx,%edx
movzbl 0x0(%r13,%rcx,1),%ebx
movzbl %bl,%r8d
movzbl %dl,%edi
mov    %r8d,%r10d
sub    %edi,%r10d
mov    %r10d,%edi
neg    %edi
cmovs  %r10d,%edi
cmp    %eax,%edi
jg     12c0 <otsu+0x1a0>
movzbl %sil,%esi
mov    %r8d,%edi
sub    %esi,%edi
mov    %edi,%esi
neg    %esi
cmovs  %edi,%esi
cmp    %eax,%esi
jg     12c0 <otsu+0x1a0>
jmp    12c9 <otsu+0x1a9>
mov    $0xff,%ebp
xor    %r15d,%r15d
xor    %r12d,%r12d
mov    0x8a8(%rsp),%r11d
xorpd  %xmm4,%xmm4
xor    %eax,%eax
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x460(%rsp,%rax,4),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
mulsd  %xmm0,%xmm1
lea    0x1(%rax),%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
mov    0x464(%rsp,%rax,4),%edx
addsd  %xmm4,%xmm1
add    0x60(%rsp,%rax,4),%r13d
xorps  %xmm4,%xmm4
cvtsi2sd %edx,%xmm4
add    %ecx,%r14d
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
add    %edx,%r14d
add    0x64(%rsp,%rax,4),%r13d
add    $0x2,%rax
cmp    $0x100,%rax
jne    1330 <otsu+0x210>
test   %r14d,%r14d
je     153a <otsu+0x41a>
test   $0x1,%r11b
movsd  %xmm4,0x18(%rsp)
je     13c8 <otsu+0x2a8>
mov    0x2c3b(%rip),%rax
mov    (%rax),%edi
lea    0xc7c(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
movsd  0x18(%rsp),%xmm4
mov    0x8a8(%rsp),%r11d
mov    0x8(%rsp),%r10
mov    0x8a0(%rsp),%eax
imul   %r10d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x38(%rsp)
mov    $0x1,%r9d
xor    %edx,%edx
xorpd  %xmm5,%xmm5
movsd  0xc0c(%rip),%xmm1
xor    %esi,%esi
jmp    1414 <otsu+0x2f4>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm1
mov    %rbx,%rdx
cmp    $0xff,%rbx
je     151c <otsu+0x3fc>
mov    0x460(%rsp,%rdx,4),%r8d
add    %r8d,%esi
je     1510 <otsu+0x3f0>
mov    %r14d,%eax
sub    %esi,%eax
je     151c <otsu+0x3fc>
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
xorps  %xmm2,%xmm2
cvtsi2sd %r8d,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm5
movapd %xmm4,%xmm2
subsd  %xmm5,%xmm2
movd   %esi,%xmm0
movd   %eax,%xmm3
punpckldq %xmm0,%xmm3
cvtdq2pd %xmm3,%xmm3
unpcklpd %xmm5,%xmm2
divpd  %xmm3,%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
subsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
lea    0x1(%rdx),%rbx
cmova  %ebx,%r9d
movapd %xmm0,%xmm2
maxsd  %xmm1,%xmm2
test   $0x1,%r11b
je     1400 <otsu+0x2e0>
mov    0x60(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
je     1400 <otsu+0x2e0>
mov    0x2b2c(%rip),%rax
mov    (%rax),%edi
divsd  0x38(%rsp),%xmm0
mov    %esi,0x10(%rsp)
lea    0xb95(%rip),%rsi
mov    $0x1,%al
mov    %r9d,(%rsp)
movapd %xmm5,0x20(%rsp)
movapd %xmm2,0x50(%rsp)
call   1040 <fprintf@plt>
mov    0x10(%rsp),%esi
movapd 0x20(%rsp),%xmm5
movsd  0x18(%rsp),%xmm4
mov    0x8a8(%rsp),%r11d
mov    (%rsp),%r9d
mov    0x8(%rsp),%r10
movapd 0x50(%rsp),%xmm1
jmp    1404 <otsu+0x2e4>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%rbx
jmp    1404 <otsu+0x2e4>
test   %r9d,%r9d
jle    155b <otsu+0x43b>
mov    %r9d,%eax
cmp    $0x8,%r9d
jae    1569 <otsu+0x449>
xor    %ecx,%ecx
xor    %ebx,%ebx
mov    0x2aab(%rip),%r14
jmp    1650 <otsu+0x530>
mov    0x2a9f(%rip),%rax
mov    (%rax),%edi
lea    0xabe(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    $0xa0,%eax
jmp    1918 <otsu+0x7f8>
xor    %ebx,%ebx
mov    0x2a7c(%rip),%r14
jmp    165d <otsu+0x53d>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1594 <otsu+0x474>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
xorpd  %xmm1,%xmm1
jmp    15fc <otsu+0x4dc>
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm0,%xmm0
xor    %esi,%esi
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddd  0x60(%rsp,%rsi,4),%xmm0
paddd  0x70(%rsp,%rsi,4),%xmm1
paddd  0x80(%rsp,%rsi,4),%xmm0
paddd  0x90(%rsp,%rsi,4),%xmm1
paddd  0xa0(%rsp,%rsi,4),%xmm0
paddd  0xb0(%rsp,%rsi,4),%xmm1
paddd  0xc0(%rsp,%rsi,4),%xmm0
paddd  0xd0(%rsp,%rsi,4),%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    15b0 <otsu+0x490>
test   %rdx,%rdx
je     1624 <otsu+0x504>
lea    (%rsp,%rsi,4),%rsi
add    $0x70,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nop
paddd  -0x10(%rsi,%rdi,1),%xmm0
paddd  (%rsi,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1610 <otsu+0x4f0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rax,%rcx
mov    0x2998(%rip),%r14
je     165d <otsu+0x53d>
nopw   0x0(%rax,%rax,1)
add    0x60(%rsp,%rcx,4),%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1650 <otsu+0x530>
cmp    %r15d,%r9d
jle    1683 <otsu+0x563>
mov    (%r14),%edi
lea    0xa10(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8a8(%rsp),%r11d
mov    0x8(%rsp),%r10
mov    %r15d,%r9d
cmp    %ebp,%r9d
jg     16aa <otsu+0x58a>
mov    (%r14),%edi
lea    0xa04(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8a8(%rsp),%r11d
mov    0x8(%rsp),%r10
lea    0x1(%rbp),%r9d
sub    %ebx,%r13d
test   $0x1,%r11b
mov    %r9d,(%rsp)
jne    16c2 <otsu+0x5a2>
shl    $0x2,%r13d
cmp    %r13d,%ebx
jge    170c <otsu+0x5ec>
jmp    16ee <otsu+0x5ce>
mov    (%r14),%edi
lea    0x9e4(%rip),%rsi
mov    %r9d,%edx
mov    %ebp,%ecx
mov    %r15d,%r8d
mov    %r12d,%r9d
xor    %eax,%eax
push   %r13
push   %rbx
call   1040 <fprintf@plt>
add    $0x10,%rsp
shl    $0x2,%r13d
cmp    %r13d,%ebx
jge    16f6 <otsu+0x5d6>
mov    (%rsp),%eax
jmp    1918 <otsu+0x7f8>
mov    (%r14),%edi
lea    0x9ea(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8(%rsp),%r10
mov    0x8a0(%rsp),%eax
test   %eax,%eax
jle    1910 <otsu+0x7f0>
movslq 0x48(%rsp),%r12
movslq 0x44(%rsp),%r11
movslq 0x4c(%rsp),%r15
mov    %eax,%r9d
lea    -0x1(%r10),%r13d
lea    0x1(%r13),%r8
mov    %r8,%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x20(%rsp)
add    $0xffffffffffffffe0,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x38(%rsp)
movabs $0x1ffffffe0,%rbx
or     $0x18,%rbx
and    %r8,%rbx
mov    %r12,%rax
imul   %r11,%rax
add    %r15,%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
add    $0x30,%rdx
mov    %rcx,%r14
add    %rcx,%rax
xor    %ebp,%ebp
pcmpeqd %xmm0,%xmm0
mov    %r8,0x10(%rsp)
jmp    17c3 <otsu+0x6a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    %r11,%rdx
add    %r11,%rax
cmp    %r9,%rbp
je     1910 <otsu+0x7f0>
test   %r10d,%r10d
jle    17b0 <otsu+0x690>
lea    (%r12,%rbp,1),%rdi
imul   %r11,%rdi
add    %r15,%rdi
add    %r14,%rdi
xor    %ecx,%ecx
cmp    $0x7,%r13d
jb     18f0 <otsu+0x7d0>
cmp    $0x1f,%r13d
jae    17ef <otsu+0x6cf>
xor    %esi,%esi
jmp    18a9 <otsu+0x789>
cmpq   $0x0,0x50(%rsp)
je     18d4 <otsu+0x7b4>
mov    0x38(%rsp),%r8
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x30(%rdx,%r10,1),%xmm1
movdqu -0x20(%rdx,%r10,1),%xmm2
movdqu -0x10(%rdx,%r10,1),%xmm3
movdqu (%rdx,%r10,1),%xmm4
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,-0x30(%rdx,%r10,1)
movdqu %xmm2,-0x20(%rdx,%r10,1)
pxor   %xmm0,%xmm3
pxor   %xmm0,%xmm4
movdqu %xmm3,-0x10(%rdx,%r10,1)
movdqu %xmm4,(%rdx,%r10,1)
add    $0x40,%r10
add    $0xfffffffffffffffe,%r8
jne    1810 <otsu+0x6f0>
testb  $0x1,0x18(%rsp)
je     1889 <otsu+0x769>
movdqu (%rdi,%r10,1),%xmm1
movdqu 0x10(%rdi,%r10,1),%xmm2
pxor   %xmm0,%xmm1
pxor   %xmm0,%xmm2
movdqu %xmm1,(%rdi,%r10,1)
movdqu %xmm2,0x10(%rdi,%r10,1)
mov    0x10(%rsp),%r8
cmp    0x20(%rsp),%r8
mov    0x8(%rsp),%r10
je     17b0 <otsu+0x690>
mov    0x20(%rsp),%rsi
test   $0x18,%r8b
je     18e0 <otsu+0x7c0>
add    %rbx,%rdi
nopl   0x0(%rax)
movq   (%rax,%rsi,1),%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    18b0 <otsu+0x790>
mov    %ebx,%ecx
cmp    %rbx,%r8
je     17b0 <otsu+0x690>
jmp    18f0 <otsu+0x7d0>
xor    %r10d,%r10d
testb  $0x1,0x18(%rsp)
jne    1867 <otsu+0x747>
jmp    1889 <otsu+0x769>
mov    0x20(%rsp),%rcx
add    %rcx,%rdi
nopl   0x0(%rax,%rax,1)
mov    %r10d,%esi
sub    %ecx,%esi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
notb   (%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %ecx,%esi
jne    1900 <otsu+0x7e0>
jmp    17b0 <otsu+0x690>
mov    $0x100,%eax
sub    (%rsp),%eax
add    $0x868,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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