void hsmooth64(long long a[], int nxtop, int nytop, int ny, int scale) {
  int i, j;
  int ny2, s10, s00;
  long long hm, h0, hp, hmm, hpm, hmp, hpp, hx2, hy2, diff, dmax, dmin, s, smax,
      m1, m2;
  smax = (scale >> 1);
  if (smax <= 0)
    return;
  ny2 = ny << 1;
  for (i = 2; i < nxtop - 2; i += 2) {
    s00 = ny * i;
    s10 = s00 + ny;
    for (j = 0; j < nytop; j += 2) {
      hm = a[s00 - ny2];
      h0 = a[s00];
      hp = a[s00 + ny2];
      diff = hp - hm;
      dmax =
          (((((((hp - h0)) < ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm)))) > (0))
               ? (((((hp - h0)) < ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm))))
               : (0))
          << 2;
      dmin =
          (((((((hp - h0)) > ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm)))) < (0))
               ? (((((hp - h0)) > ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm))))
               : (0))
          << 2;
      if (dmin < dmax) {
        diff = ((((((diff) < (dmax)) ? (diff) : (dmax))) > (dmin))
                    ? ((((diff) < (dmax)) ? (diff) : (dmax)))
                    : (dmin));
        s = diff - (a[s10] << 3);
        s = (s >= 0) ? (s >> 3) : ((s + 7) >> 3);
        s = ((((((s) < (smax)) ? (s) : (smax))) > (-smax))
                 ? ((((s) < (smax)) ? (s) : (smax)))
                 : (-smax));
        a[s10] = a[s10] + s;
      }
      s00 += 2;
      s10 += 2;
    }
  }
  for (i = 0; i < nxtop; i += 2) {
    s00 = ny * i + 2;
    s10 = s00 + ny;
    for (j = 2; j < nytop - 2; j += 2) {
      hm = a[s00 - 2];
      h0 = a[s00];
      hp = a[s00 + 2];
      diff = hp - hm;
      dmax =
          (((((((hp - h0)) < ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm)))) > (0))
               ? (((((hp - h0)) < ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm))))
               : (0))
          << 2;
      dmin =
          (((((((hp - h0)) > ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm)))) < (0))
               ? (((((hp - h0)) > ((h0 - hm))) ? ((hp - h0)) : ((h0 - hm))))
               : (0))
          << 2;
      if (dmin < dmax) {
        diff = ((((((diff) < (dmax)) ? (diff) : (dmax))) > (dmin))
                    ? ((((diff) < (dmax)) ? (diff) : (dmax)))
                    : (dmin));
        s = diff - (a[s00 + 1] << 3);
        s = (s >= 0) ? (s >> 3) : ((s + 7) >> 3);
        s = ((((((s) < (smax)) ? (s) : (smax))) > (-smax))
                 ? ((((s) < (smax)) ? (s) : (smax)))
                 : (-smax));
        a[s00 + 1] = a[s00 + 1] + s;
      }
      s00 += 2;
      s10 += 2;
    }
  }
  for (i = 2; i < nxtop - 2; i += 2) {
    s00 = ny * i + 2;
    s10 = s00 + ny;
    for (j = 2; j < nytop - 2; j += 2) {
      hmm = a[s00 - ny2 - 2];
      hpm = a[s00 + ny2 - 2];
      hmp = a[s00 - ny2 + 2];
      hpp = a[s00 + ny2 + 2];
      h0 = a[s00];
      diff = hpp + hmm - hmp - hpm;
      hx2 = a[s10] << 1;
      hy2 = a[s00 + 1] << 1;
      m1 = ((((((hpp - h0) > (0)) ? (hpp - h0) : (0)) - hx2 - hy2) <
             ((((h0 - hpm) > (0)) ? (h0 - hpm) : (0)) + hx2 - hy2))
                ? ((((hpp - h0) > (0)) ? (hpp - h0) : (0)) - hx2 - hy2)
                : ((((h0 - hpm) > (0)) ? (h0 - hpm) : (0)) + hx2 - hy2));
      m2 = ((((((h0 - hmp) > (0)) ? (h0 - hmp) : (0)) - hx2 + hy2) <
             ((((hmm - h0) > (0)) ? (hmm - h0) : (0)) + hx2 + hy2))
                ? ((((h0 - hmp) > (0)) ? (h0 - hmp) : (0)) - hx2 + hy2)
                : ((((hmm - h0) > (0)) ? (hmm - h0) : (0)) + hx2 + hy2));
      dmax = (((m1) < (m2)) ? (m1) : (m2)) << 4;
      m1 = ((((((hpp - h0) < (0)) ? (hpp - h0) : (0)) - hx2 - hy2) >
             ((((h0 - hpm) < (0)) ? (h0 - hpm) : (0)) + hx2 - hy2))
                ? ((((hpp - h0) < (0)) ? (hpp - h0) : (0)) - hx2 - hy2)
                : ((((h0 - hpm) < (0)) ? (h0 - hpm) : (0)) + hx2 - hy2));
      m2 = ((((((h0 - hmp) < (0)) ? (h0 - hmp) : (0)) - hx2 + hy2) >
             ((((hmm - h0) < (0)) ? (hmm - h0) : (0)) + hx2 + hy2))
                ? ((((h0 - hmp) < (0)) ? (h0 - hmp) : (0)) - hx2 + hy2)
                : ((((hmm - h0) < (0)) ? (hmm - h0) : (0)) + hx2 + hy2));
      dmin = (((m1) > (m2)) ? (m1) : (m2)) << 4;
      if (dmin < dmax) {
        diff = ((((((diff) < (dmax)) ? (diff) : (dmax))) > (dmin))
                    ? ((((diff) < (dmax)) ? (diff) : (dmax)))
                    : (dmin));
        s = diff - (a[s10 + 1] << 6);
        s = (s >= 0) ? (s >> 6) : ((s + 63) >> 6);
        s = ((((((s) < (smax)) ? (s) : (smax))) > (-smax))
                 ? ((((s) < (smax)) ? (s) : (smax)))
                 : (-smax));
        a[s10 + 1] = a[s10 + 1] + s;
      }
      s00 += 2;
      s10 += 2;
    }
  }
}


x86 assembly (clang, -O0):
<hsmooth64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x208,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0x18(%rbp),%eax
sar    $0x1,%eax
cltq
mov    %rax,-0xa0(%rbp)
cmpq   $0x0,-0xa0(%rbp)
jg     113e <hsmooth64+0x3e>
jmp    2252 <hsmooth64+0x1152>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1562 <hsmooth64+0x462>
mov    -0x14(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    154f <hsmooth64+0x44f>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jge    11f8 <hsmooth64+0xf8>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    1207 <hsmooth64+0x107>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
cmp    $0x0,%rax
jle    1267 <hsmooth64+0x167>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jge    1245 <hsmooth64+0x145>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0xc0(%rbp)
jmp    1254 <hsmooth64+0x154>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    1275 <hsmooth64+0x175>
xor    %eax,%eax
mov    %rax,-0xc8(%rbp)
jmp    1275 <hsmooth64+0x175>
mov    -0xc8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jle    12b4 <hsmooth64+0x1b4>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0xd0(%rbp)
jmp    12c3 <hsmooth64+0x1c3>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
cmp    $0x0,%rax
jge    1323 <hsmooth64+0x223>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jle    1301 <hsmooth64+0x201>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0xd8(%rbp)
jmp    1310 <hsmooth64+0x210>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
jmp    1331 <hsmooth64+0x231>
xor    %eax,%eax
mov    %rax,-0xe0(%rbp)
jmp    1331 <hsmooth64+0x231>
mov    -0xe0(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    152f <hsmooth64+0x42f>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    1378 <hsmooth64+0x278>
mov    -0x80(%rbp),%rax
mov    %rax,-0xe8(%rbp)
jmp    1386 <hsmooth64+0x286>
mov    -0x88(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
cmp    -0x90(%rbp),%rax
jle    13dc <hsmooth64+0x2dc>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    13bb <hsmooth64+0x2bb>
mov    -0x80(%rbp),%rax
mov    %rax,-0xf0(%rbp)
jmp    13c9 <hsmooth64+0x2c9>
mov    -0x88(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0xf8(%rbp)
jmp    13ea <hsmooth64+0x2ea>
mov    -0x90(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
sub    %rcx,%rax
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
jl     1438 <hsmooth64+0x338>
mov    -0x98(%rbp),%rax
sar    $0x3,%rax
mov    %rax,-0x100(%rbp)
jmp    144e <hsmooth64+0x34e>
mov    -0x98(%rbp),%rax
add    $0x7,%rax
sar    $0x3,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    1483 <hsmooth64+0x383>
mov    -0x98(%rbp),%rax
mov    %rax,-0x108(%rbp)
jmp    1491 <hsmooth64+0x391>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
xor    %ecx,%ecx
sub    -0xa0(%rbp),%rcx
cmp    %rcx,%rax
jle    14f2 <hsmooth64+0x3f2>
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    14d1 <hsmooth64+0x3d1>
mov    -0x98(%rbp),%rax
mov    %rax,-0x110(%rbp)
jmp    14df <hsmooth64+0x3df>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    %rax,-0x118(%rbp)
jmp    1502 <hsmooth64+0x402>
xor    %eax,%eax
sub    -0xa0(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    -0x98(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    1179 <hsmooth64+0x79>
jmp    1554 <hsmooth64+0x454>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    114e <hsmooth64+0x4e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    198f <hsmooth64+0x88f>
mov    -0x14(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x2,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    197c <hsmooth64+0x87c>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jge    1616 <hsmooth64+0x516>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x120(%rbp)
jmp    1625 <hsmooth64+0x525>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
cmp    $0x0,%rax
jle    1685 <hsmooth64+0x585>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jge    1663 <hsmooth64+0x563>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x128(%rbp)
jmp    1672 <hsmooth64+0x572>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x130(%rbp)
jmp    1693 <hsmooth64+0x593>
xor    %eax,%eax
mov    %rax,-0x130(%rbp)
jmp    1693 <hsmooth64+0x593>
mov    -0x130(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jle    16d2 <hsmooth64+0x5d2>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x138(%rbp)
jmp    16e1 <hsmooth64+0x5e1>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
cmp    $0x0,%rax
jge    1741 <hsmooth64+0x641>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jle    171f <hsmooth64+0x61f>
mov    -0x48(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x140(%rbp)
jmp    172e <hsmooth64+0x62e>
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
jmp    174f <hsmooth64+0x64f>
xor    %eax,%eax
mov    %rax,-0x148(%rbp)
jmp    174f <hsmooth64+0x64f>
mov    -0x148(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    195c <hsmooth64+0x85c>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    1796 <hsmooth64+0x696>
mov    -0x80(%rbp),%rax
mov    %rax,-0x150(%rbp)
jmp    17a4 <hsmooth64+0x6a4>
mov    -0x88(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
cmp    -0x90(%rbp),%rax
jle    17fa <hsmooth64+0x6fa>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    17d9 <hsmooth64+0x6d9>
mov    -0x80(%rbp),%rax
mov    %rax,-0x158(%rbp)
jmp    17e7 <hsmooth64+0x6e7>
mov    -0x88(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rax
mov    %rax,-0x160(%rbp)
jmp    1808 <hsmooth64+0x708>
mov    -0x90(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
sub    %rcx,%rax
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
jl     185b <hsmooth64+0x75b>
mov    -0x98(%rbp),%rax
sar    $0x3,%rax
mov    %rax,-0x168(%rbp)
jmp    1871 <hsmooth64+0x771>
mov    -0x98(%rbp),%rax
add    $0x7,%rax
sar    $0x3,%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    18a6 <hsmooth64+0x7a6>
mov    -0x98(%rbp),%rax
mov    %rax,-0x170(%rbp)
jmp    18b4 <hsmooth64+0x7b4>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x170(%rbp),%rax
xor    %ecx,%ecx
sub    -0xa0(%rbp),%rcx
cmp    %rcx,%rax
jle    1915 <hsmooth64+0x815>
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    18f4 <hsmooth64+0x7f4>
mov    -0x98(%rbp),%rax
mov    %rax,-0x178(%rbp)
jmp    1902 <hsmooth64+0x802>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x178(%rbp),%rax
mov    %rax,-0x180(%rbp)
jmp    1925 <hsmooth64+0x825>
xor    %eax,%eax
sub    -0xa0(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x180(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
add    -0x98(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    1592 <hsmooth64+0x492>
jmp    1981 <hsmooth64+0x881>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1569 <hsmooth64+0x469>
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    2252 <hsmooth64+0x1152>
mov    -0x14(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x2,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    223f <hsmooth64+0x113f>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
add    -0x50(%rbp),%rax
sub    -0x60(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jle    1aac <hsmooth64+0x9ac>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x188(%rbp)
jmp    1aba <hsmooth64+0x9ba>
xor    %eax,%eax
mov    %rax,-0x188(%rbp)
jmp    1aba <hsmooth64+0x9ba>
mov    -0x188(%rbp),%rax
sub    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
cmp    $0x0,%rax
jle    1af6 <hsmooth64+0x9f6>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x198(%rbp)
jmp    1b04 <hsmooth64+0xa04>
xor    %eax,%eax
mov    %rax,-0x198(%rbp)
jmp    1b04 <hsmooth64+0xa04>
mov    -0x190(%rbp),%rax
mov    -0x198(%rbp),%rcx
add    -0x70(%rbp),%rcx
sub    -0x78(%rbp),%rcx
cmp    %rcx,%rax
jge    1b72 <hsmooth64+0xa72>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jle    1b49 <hsmooth64+0xa49>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
jmp    1b57 <hsmooth64+0xa57>
xor    %eax,%eax
mov    %rax,-0x1a0(%rbp)
jmp    1b57 <hsmooth64+0xa57>
mov    -0x1a0(%rbp),%rax
sub    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
jmp    1bbc <hsmooth64+0xabc>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
cmp    $0x0,%rax
jle    1b98 <hsmooth64+0xa98>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
jmp    1ba6 <hsmooth64+0xaa6>
xor    %eax,%eax
mov    %rax,-0x1b0(%rbp)
jmp    1ba6 <hsmooth64+0xaa6>
mov    -0x1b0(%rbp),%rax
add    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
cmp    $0x0,%rax
jle    1bf0 <hsmooth64+0xaf0>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
jmp    1bfe <hsmooth64+0xafe>
xor    %eax,%eax
mov    %rax,-0x1b8(%rbp)
jmp    1bfe <hsmooth64+0xafe>
mov    -0x1b8(%rbp),%rax
sub    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jle    1c3a <hsmooth64+0xb3a>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
jmp    1c48 <hsmooth64+0xb48>
xor    %eax,%eax
mov    %rax,-0x1c8(%rbp)
jmp    1c48 <hsmooth64+0xb48>
mov    -0x1c0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
add    -0x70(%rbp),%rcx
add    -0x78(%rbp),%rcx
cmp    %rcx,%rax
jge    1cb6 <hsmooth64+0xbb6>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
cmp    $0x0,%rax
jle    1c8d <hsmooth64+0xb8d>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
jmp    1c9b <hsmooth64+0xb9b>
xor    %eax,%eax
mov    %rax,-0x1d0(%rbp)
jmp    1c9b <hsmooth64+0xb9b>
mov    -0x1d0(%rbp),%rax
sub    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
jmp    1d00 <hsmooth64+0xc00>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jle    1cdc <hsmooth64+0xbdc>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
jmp    1cea <hsmooth64+0xbea>
xor    %eax,%eax
mov    %rax,-0x1e0(%rbp)
jmp    1cea <hsmooth64+0xbea>
mov    -0x1e0(%rbp),%rax
add    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jge    1d35 <hsmooth64+0xc35>
mov    -0xa8(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
jmp    1d43 <hsmooth64+0xc43>
mov    -0xb0(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jge    1d7b <hsmooth64+0xc7b>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    1d89 <hsmooth64+0xc89>
xor    %eax,%eax
mov    %rax,-0x1f0(%rbp)
jmp    1d89 <hsmooth64+0xc89>
mov    -0x1f0(%rbp),%rax
sub    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
cmp    $0x0,%rax
jge    1dc5 <hsmooth64+0xcc5>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x200(%rbp)
jmp    1dd3 <hsmooth64+0xcd3>
xor    %eax,%eax
mov    %rax,-0x200(%rbp)
jmp    1dd3 <hsmooth64+0xcd3>
mov    -0x1f8(%rbp),%rax
mov    -0x200(%rbp),%rcx
add    -0x70(%rbp),%rcx
sub    -0x78(%rbp),%rcx
cmp    %rcx,%rax
jle    1e41 <hsmooth64+0xd41>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jge    1e18 <hsmooth64+0xd18>
mov    -0x68(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x208(%rbp)
jmp    1e26 <hsmooth64+0xd26>
xor    %eax,%eax
mov    %rax,-0x208(%rbp)
jmp    1e26 <hsmooth64+0xd26>
mov    -0x208(%rbp),%rax
sub    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    1e8b <hsmooth64+0xd8b>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
cmp    $0x0,%rax
jge    1e67 <hsmooth64+0xd67>
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x218(%rbp)
jmp    1e75 <hsmooth64+0xd75>
xor    %eax,%eax
mov    %rax,-0x218(%rbp)
jmp    1e75 <hsmooth64+0xd75>
mov    -0x218(%rbp),%rax
add    -0x70(%rbp),%rax
sub    -0x78(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0x210(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
cmp    $0x0,%rax
jge    1ebf <hsmooth64+0xdbf>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
mov    %rax,-0x220(%rbp)
jmp    1ecd <hsmooth64+0xdcd>
xor    %eax,%eax
mov    %rax,-0x220(%rbp)
jmp    1ecd <hsmooth64+0xdcd>
mov    -0x220(%rbp),%rax
sub    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jge    1f09 <hsmooth64+0xe09>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x230(%rbp)
jmp    1f17 <hsmooth64+0xe17>
xor    %eax,%eax
mov    %rax,-0x230(%rbp)
jmp    1f17 <hsmooth64+0xe17>
mov    -0x228(%rbp),%rax
mov    -0x230(%rbp),%rcx
add    -0x70(%rbp),%rcx
add    -0x78(%rbp),%rcx
cmp    %rcx,%rax
jle    1f85 <hsmooth64+0xe85>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
cmp    $0x0,%rax
jge    1f5c <hsmooth64+0xe5c>
mov    -0x40(%rbp),%rax
sub    -0x60(%rbp),%rax
mov    %rax,-0x238(%rbp)
jmp    1f6a <hsmooth64+0xe6a>
xor    %eax,%eax
mov    %rax,-0x238(%rbp)
jmp    1f6a <hsmooth64+0xe6a>
mov    -0x238(%rbp),%rax
sub    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x240(%rbp)
jmp    1fcf <hsmooth64+0xecf>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x0,%rax
jge    1fab <hsmooth64+0xeab>
mov    -0x50(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x248(%rbp)
jmp    1fb9 <hsmooth64+0xeb9>
xor    %eax,%eax
mov    %rax,-0x248(%rbp)
jmp    1fb9 <hsmooth64+0xeb9>
mov    -0x248(%rbp),%rax
add    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x240(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jle    2004 <hsmooth64+0xf04>
mov    -0xa8(%rbp),%rax
mov    %rax,-0x250(%rbp)
jmp    2012 <hsmooth64+0xf12>
mov    -0xb0(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    221f <hsmooth64+0x111f>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    2059 <hsmooth64+0xf59>
mov    -0x80(%rbp),%rax
mov    %rax,-0x258(%rbp)
jmp    2067 <hsmooth64+0xf67>
mov    -0x88(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x258(%rbp),%rax
cmp    -0x90(%rbp),%rax
jle    20bd <hsmooth64+0xfbd>
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    209c <hsmooth64+0xf9c>
mov    -0x80(%rbp),%rax
mov    %rax,-0x260(%rbp)
jmp    20aa <hsmooth64+0xfaa>
mov    -0x88(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x260(%rbp),%rax
mov    %rax,-0x268(%rbp)
jmp    20cb <hsmooth64+0xfcb>
mov    -0x90(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x268(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
shl    $0x6,%rcx
sub    %rcx,%rax
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
jl     211e <hsmooth64+0x101e>
mov    -0x98(%rbp),%rax
sar    $0x6,%rax
mov    %rax,-0x270(%rbp)
jmp    2134 <hsmooth64+0x1034>
mov    -0x98(%rbp),%rax
add    $0x3f,%rax
sar    $0x6,%rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    2169 <hsmooth64+0x1069>
mov    -0x98(%rbp),%rax
mov    %rax,-0x278(%rbp)
jmp    2177 <hsmooth64+0x1077>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x278(%rbp),%rax
xor    %ecx,%ecx
sub    -0xa0(%rbp),%rcx
cmp    %rcx,%rax
jle    21d8 <hsmooth64+0x10d8>
mov    -0x98(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    21b7 <hsmooth64+0x10b7>
mov    -0x98(%rbp),%rax
mov    %rax,-0x280(%rbp)
jmp    21c5 <hsmooth64+0x10c5>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x280(%rbp),%rax
mov    %rax,-0x288(%rbp)
jmp    21e8 <hsmooth64+0x10e8>
xor    %eax,%eax
sub    -0xa0(%rbp),%rax
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
add    -0x98(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    19c4 <hsmooth64+0x8c4>
jmp    2244 <hsmooth64+0x1144>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1996 <hsmooth64+0x896>
add    $0x208,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hsmooth64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,-0x68(%rsp)
mov    %rdi,-0x70(%rsp)
cmp    $0x2,%r8d
jl     1632 <hsmooth64+0x532>
sar    %r8d
movslq %r8d,%rax
mov    %rax,-0x78(%rsp)
mov    %rcx,-0x50(%rsp)
lea    (%rcx,%rcx,1),%eax
lea    -0x2(%rsi),%ecx
mov    %ecx,-0x54(%rsp)
mov    %eax,-0x7c(%rsp)
cltq
mov    %rax,-0x40(%rsp)
mov    %rsi,-0x38(%rsp)
cmp    $0x5,%esi
jl     128f <hsmooth64+0x18f>
mov    -0x78(%rsp),%r13
neg    %r13
mov    -0x50(%rsp),%rax
lea    (%rax,%rax,2),%esi
mov    -0x40(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    -0x70(%rsp),%rdx
mov    %rcx,%rax
mov    %rcx,-0x48(%rsp)
sub    %rcx,%rdx
mov    %rdx,-0x30(%rsp)
mov    $0x2,%r15d
xor    %r12d,%r12d
mov    -0x7c(%rsp),%r14d
jmp    11b8 <hsmooth64+0xb8>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r15d
mov    -0x7c(%rsp),%eax
add    %eax,%esi
add    %eax,%r14d
cmp    -0x54(%rsp),%r15d
jge    128f <hsmooth64+0x18f>
cmpl   $0x0,-0x68(%rsp)
jle    11a0 <hsmooth64+0xa0>
movslq %r14d,%rax
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%r9
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
movslq %esi,%rax
lea    (%rcx,%rax,8),%rax
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rbp,1),%r8
xor    %edi,%edi
jmp    1201 <hsmooth64+0x101>
nopl   0x0(%rax,%rax,1)
add    %rcx,%rbx
mov    %rbx,(%rax,%rdi,8)
add    $0x2,%rdi
cmp    -0x68(%rsp),%edi
jge    11a0 <hsmooth64+0xa0>
mov    (%r9,%rdi,8),%rcx
mov    0x0(%rbp,%rdi,8),%r11
mov    (%r8,%rdi,8),%rdx
mov    %rdx,%rbx
sub    %r11,%rbx
sub    %rcx,%r11
cmp    %r11,%rbx
mov    %r11,%r10
cmovl  %rbx,%r10
cmovg  %rbx,%r11
test   %r10,%r10
cmovs  %r12,%r10
shl    $0x2,%r10
mov    %r11,%rbx
sar    $0x3f,%rbx
and    %r11,%rbx
shl    $0x2,%rbx
cmp    %r10,%rbx
jge    11f7 <hsmooth64+0xf7>
sub    %rcx,%rdx
cmp    %r10,%rdx
cmovge %r10,%rdx
cmp    %rbx,%rdx
cmovle %rbx,%rdx
mov    (%rax,%rdi,8),%rcx
lea    0x0(,%rcx,8),%rbx
sub    %rbx,%rdx
lea    0x7(%rdx),%rbx
test   %rdx,%rdx
cmovns %rdx,%rbx
sar    $0x3,%rbx
cmp    -0x78(%rsp),%rbx
jl     127e <hsmooth64+0x17e>
mov    -0x78(%rsp),%rbx
cmp    %r13,%rbx
jg     11f0 <hsmooth64+0xf0>
mov    %r13,%rbx
jmp    11f0 <hsmooth64+0xf0>
mov    -0x38(%rsp),%r15
test   %r15d,%r15d
jle    1393 <hsmooth64+0x293>
mov    -0x68(%rsp),%rax
lea    -0x2(%rax),%r11d
mov    -0x78(%rsp),%r14
neg    %r14
xor    %r10d,%r10d
mov    $0x2,%r8d
xor    %r9d,%r9d
jmp    12d2 <hsmooth64+0x1d2>
nopl   0x0(%rax)
add    $0x2,%r9d
add    -0x7c(%rsp),%r8d
cmp    %r15d,%r9d
jge    1393 <hsmooth64+0x293>
cmpl   $0x5,-0x68(%rsp)
jl     12c0 <hsmooth64+0x1c0>
movslq %r8d,%rax
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    (%rcx,%rax,8),%rcx
mov    $0x2,%ebx
jmp    1301 <hsmooth64+0x201>
add    %rdx,%rdi
mov    %rdi,-0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %r11d,%ebx
jge    12c0 <hsmooth64+0x1c0>
mov    %rcx,%rsi
mov    -0x20(%rbp,%rbx,8),%rdx
mov    0x0(%rbp,%rbx,8),%rcx
mov    %rcx,%rax
sub    %rsi,%rax
sub    %rdx,%rsi
cmp    %rsi,%rax
mov    %rsi,%rdi
cmovl  %rax,%rdi
cmovg  %rax,%rsi
test   %rdi,%rdi
cmovs  %r10,%rdi
shl    $0x2,%rdi
mov    %rsi,%rax
sar    $0x3f,%rax
and    %rsi,%rax
shl    $0x2,%rax
cmp    %rdi,%rax
jge    12f8 <hsmooth64+0x1f8>
mov    %rcx,%rsi
sub    %rdx,%rsi
cmp    %rdi,%rsi
cmovge %rdi,%rsi
cmp    %rax,%rsi
cmovle %rax,%rsi
mov    -0x8(%rbp,%rbx,8),%rdx
lea    0x0(,%rdx,8),%rax
sub    %rax,%rsi
lea    0x7(%rsi),%rdi
test   %rsi,%rsi
cmovns %rsi,%rdi
sar    $0x3,%rdi
cmp    -0x78(%rsp),%rdi
jl     1382 <hsmooth64+0x282>
mov    -0x78(%rsp),%rdi
cmp    %r14,%rdi
jg     12f0 <hsmooth64+0x1f0>
mov    %r14,%rdi
jmp    12f0 <hsmooth64+0x1f0>
cmp    $0x5,%r15d
mov    -0x50(%rsp),%rcx
jl     1632 <hsmooth64+0x532>
mov    -0x68(%rsp),%rax
add    $0xfffffffe,%eax
mov    %eax,-0x24(%rsp)
mov    -0x78(%rsp),%rax
neg    %rax
mov    %rax,-0x8(%rsp)
lea    (%rcx,%rcx,2),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rsp)
mov    -0x40(%rsp),%rcx
lea    0x2(%rcx),%eax
mov    %eax,-0x5c(%rsp)
mov    $0x2,%eax
sub    %rcx,%rax
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x10(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,-0x18(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,-0x20(%rsp)
mov    $0x2,%ecx
jmp    141d <hsmooth64+0x31d>
mov    -0x28(%rsp),%ecx
add    $0x2,%ecx
mov    -0x7c(%rsp),%eax
add    %eax,-0x58(%rsp)
add    %eax,-0x5c(%rsp)
cmp    -0x54(%rsp),%ecx
jge    1632 <hsmooth64+0x532>
mov    %ecx,-0x28(%rsp)
cmpl   $0x5,-0x68(%rsp)
jl     1400 <hsmooth64+0x300>
movslq -0x5c(%rsp),%r15
mov    -0x40(%rsp),%rax
add    %r15,%rax
mov    -0x10(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
mov    %rcx,0x10(%rsp)
mov    -0x70(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
mov    %rcx,0x8(%rsp)
shl    $0x20,%r15
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,(%rsp)
movslq -0x58(%rsp),%rax
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x48(%rsp)
xor    %r8d,%r8d
jmp    149f <hsmooth64+0x39f>
nopw   0x0(%rax,%rax,1)
movabs $0x200000000,%rax
add    %rax,%r15
add    $0x2,%r8
lea    0x2(%r8),%eax
cmp    -0x24(%rsp),%eax
jge    1400 <hsmooth64+0x300>
mov    0x10(%rsp),%rax
mov    -0x20(%rax,%r8,8),%r9
mov    (%rax,%r8,8),%r13
mov    (%rsp),%rax
mov    -0x20(%rax,%r8,8),%rbx
mov    (%rax,%r8,8),%rbp
mov    0x8(%rsp),%rax
mov    (%rax,%r8,8),%rcx
mov    -0x48(%rsp),%rax
mov    -0x8(%rax,%r8,8),%rdi
lea    (%rdi,%rdi,1),%rax
mov    %r15,%rdx
sar    $0x1d,%rdx
or     $0x8,%rdx
mov    -0x70(%rsp),%rsi
mov    (%rsi,%rdx,1),%rdx
lea    (%rdx,%rdx,1),%r14
mov    %rbp,-0x30(%rsp)
mov    %rbp,%rsi
sub    %rcx,%rsi
mov    $0x0,%ebp
cmovns %rsi,%rbp
lea    (%rax,%rdx,2),%r11
sub    %r11,%rbp
mov    %rcx,%r10
mov    %rbx,-0x50(%rsp)
sub    %rbx,%r10
mov    $0x0,%ebx
cmovns %r10,%rbx
lea    (%rbx,%rdi,2),%rbx
sub    %r14,%rbx
cmp    %rbx,%rbp
cmovl  %rbp,%rbx
mov    %rcx,%r12
mov    %r13,-0x38(%rsp)
sub    %r13,%r12
mov    $0x0,%ebp
cmovns %r12,%rbp
sub    %rax,%rbp
mov    %r9,%r13
sub    %rcx,%r13
mov    $0x0,%ecx
cmovns %r13,%rcx
lea    (%rcx,%rdi,2),%rcx
cmp    %rcx,%rbp
cmovge %rcx,%rbp
lea    0x0(,%rdx,2),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
cmovge %rcx,%rbx
mov    %rsi,%rcx
sar    $0x3f,%rcx
and    %rsi,%rcx
sub    %r11,%rcx
mov    %r10,%rsi
sar    $0x3f,%rsi
and    %r10,%rsi
lea    (%rsi,%rdi,2),%rsi
sub    %r14,%rsi
shl    $0x4,%rbx
cmp    %rsi,%rcx
cmovg  %rcx,%rsi
mov    %r12,%rcx
sar    $0x3f,%rcx
and    %r12,%rcx
sub    %rax,%rcx
mov    %r13,%rax
sar    $0x3f,%rax
and    %r13,%rax
lea    (%rax,%rdi,2),%rax
cmp    %rax,%rcx
cmovle %rax,%rcx
lea    (%rcx,%rdx,2),%rax
cmp    %rax,%rsi
cmovle %rax,%rsi
shl    $0x4,%rsi
cmp    %rbx,%rsi
jge    1480 <hsmooth64+0x380>
mov    -0x50(%rsp),%rax
add    -0x38(%rsp),%rax
sub    %rax,%r9
add    -0x30(%rsp),%r9
cmp    %rbx,%r9
cmovge %rbx,%r9
cmp    %rsi,%r9
cmovle %rsi,%r9
mov    -0x48(%rsp),%rsi
mov    (%rsi,%r8,8),%rax
mov    %rax,%rcx
shl    $0x6,%rcx
sub    %rcx,%r9
lea    0x3f(%r9),%rcx
test   %r9,%r9
cmovns %r9,%rcx
sar    $0x6,%rcx
mov    -0x78(%rsp),%rdx
cmp    %rdx,%rcx
cmovge %rdx,%rcx
mov    -0x8(%rsp),%rdx
cmp    %rdx,%rcx
cmovle %rdx,%rcx
add    %rax,%rcx
mov    %rcx,(%rsi,%r8,8)
jmp    1480 <hsmooth64+0x380>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @hsmooth64(i64* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = ashr i32 %4, 1
%7 = sext i32 %6 to i64
%8 = icmp slt i32 %4, 2
br i1 %8, label %267, label %9
9: ; preds = %5
%10 = shl i32 %3, 1
%11 = add nsw i32 %1, -2
%12 = icmp sgt i32 %1, 4
br i1 %12, label %13, label %18
13: ; preds = %9
%14 = icmp sgt i32 %2, 0
%15 = sub nsw i64 0, %7
%16 = mul i32 %3, 3
%17 = sext i32 %10 to i64
br label %24
18: ; preds = %80, %9
%19 = icmp sgt i32 %1, 0
br i1 %19, label %20, label %85
20: ; preds = %18
%21 = add nsw i32 %2, -2
%22 = icmp sgt i32 %2, 4
%23 = sub nsw i64 0, %7
br label %94
24: ; preds = %13, %80
%25 = phi i32 [ %10, %13 ], [ %84, %80 ]
%26 = phi i32 [ %16, %13 ], [ %83, %80 ]
%27 = phi i32 [ 2, %13 ], [ %81, %80 ]
br i1 %14, label %28, label %80
28: ; preds = %24
%29 = sext i32 %25 to i64
%30 = sext i32 %26 to i64
br label %31
31: ; preds = %28, %75
%32 = phi i64 [ %29, %28 ], [ %76, %75 ]
%33 = phi i64 [ %30, %28 ], [ %77, %75 ]
%34 = phi i32 [ 0, %28 ], [ %78, %75 ]
%35 = sub nsw i64 %32, %17
%36 = getelementptr inbounds i64, i64* %0, i64 %35
%37 = load i64, i64* %36
%38 = getelementptr inbounds i64, i64* %0, i64 %32
%39 = load i64, i64* %38
%40 = add nsw i64 %32, %17
%41 = getelementptr inbounds i64, i64* %0, i64 %40
%42 = load i64, i64* %41
%43 = sub nsw i64 %42, %37
%44 = sub nsw i64 %42, %39
%45 = sub nsw i64 %39, %37
%46 = icmp slt i64 %44, %45
%47 = select i1 %46, i64 %44, i64 %45
%48 = icmp sgt i64 %47, 0
%49 = select i1 %48, i64 %47, i64 0
%50 = shl i64 %49, 2
%51 = icmp sgt i64 %44, %45
%52 = select i1 %51, i64 %44, i64 %45
%53 = icmp slt i64 %52, 0
%54 = select i1 %53, i64 %52, i64 0
%55 = shl i64 %54, 2
%56 = icmp slt i64 %55, %50
br i1 %56, label %57, label %75
57: ; preds = %31
%58 = icmp slt i64 %43, %50
%59 = select i1 %58, i64 %43, i64 %50
%60 = icmp sgt i64 %59, %55
%61 = select i1 %60, i64 %59, i64 %55
%62 = getelementptr inbounds i64, i64* %0, i64 %33
%63 = load i64, i64* %62
%64 = mul i64 %63, -8
%65 = add i64 %64, %61
%66 = icmp sgt i64 %65, -1
%67 = add nsw i64 %65, 7
%68 = select i1 %66, i64 %65, i64 %67
%69 = ashr i64 %68, 3
%70 = icmp slt i64 %69, %7
%71 = select i1 %70, i64 %69, i64 %7
%72 = icmp sgt i64 %71, %15
%73 = select i1 %72, i64 %71, i64 %15
%74 = add nsw i64 %73, %63
store i64 %74, i64* %62
br label %75
75: ; preds = %57, %31
%76 = add nsw i64 %32, 2
%77 = add nsw i64 %33, 2
%78 = add nuw nsw i32 %34, 2
%79 = icmp slt i32 %78, %2
br i1 %79, label %31, label %80
80: ; preds = %75, %24
%81 = add nuw nsw i32 %27, 2
%82 = icmp slt i32 %81, %11
%83 = add i32 %26, %10
%84 = add i32 %25, %10
br i1 %82, label %24, label %18
85: ; preds = %147, %18
br i1 %12, label %86, label %267
86: ; preds = %85
%87 = add nsw i32 %2, -2
%88 = icmp sgt i32 %2, 4
%89 = sub nsw i64 0, %7
%90 = mul i32 %3, 3
%91 = add i32 %90, 2
%92 = add i32 %10, 2
%93 = sext i32 %10 to i64
br label %151
94: ; preds = %20, %147
%95 = phi i32 [ 2, %20 ], [ %150, %147 ]
%96 = phi i32 [ 0, %20 ], [ %148, %147 ]
%97 = sext i32 %95 to i64
br i1 %22, label %98, label %147
98: ; preds = %94
%99 = getelementptr inbounds i64, i64* %0, i64 %97
%100 = load i64, i64* %99
br label %101
101: ; preds = %98, %144
%102 = phi i64 [ %100, %98 ], [ %110, %144 ]
%103 = phi i64 [ %97, %98 ], [ %108, %144 ]
%104 = phi i32 [ 2, %98 ], [ %145, %144 ]
%105 = add nsw i64 %103, -2
%106 = getelementptr inbounds i64, i64* %0, i64 %105
%107 = load i64, i64* %106
%108 = add nsw i64 %103, 2
%109 = getelementptr inbounds i64, i64* %0, i64 %108
%110 = load i64, i64* %109
%111 = sub nsw i64 %110, %107
%112 = sub nsw i64 %110, %102
%113 = sub nsw i64 %102, %107
%114 = icmp slt i64 %112, %113
%115 = select i1 %114, i64 %112, i64 %113
%116 = icmp sgt i64 %115, 0
%117 = select i1 %116, i64 %115, i64 0
%118 = shl i64 %117, 2
%119 = icmp sgt i64 %112, %113
%120 = select i1 %119, i64 %112, i64 %113
%121 = icmp slt i64 %120, 0
%122 = select i1 %121, i64 %120, i64 0
%123 = shl i64 %122, 2
%124 = icmp slt i64 %123, %118
br i1 %124, label %125, label %144
125: ; preds = %101
%126 = icmp slt i64 %111, %118
%127 = select i1 %126, i64 %111, i64 %118
%128 = icmp sgt i64 %127, %123
%129 = select i1 %128, i64 %127, i64 %123
%130 = or i64 %103, 1
%131 = getelementptr inbounds i64, i64* %0, i64 %130
%132 = load i64, i64* %131
%133 = mul i64 %132, -8
%134 = add i64 %133, %129
%135 = icmp sgt i64 %134, -1
%136 = add nsw i64 %134, 7
%137 = select i1 %135, i64 %134, i64 %136
%138 = ashr i64 %137, 3
%139 = icmp slt i64 %138, %7
%140 = select i1 %139, i64 %138, i64 %7
%141 = icmp sgt i64 %140, %23
%142 = select i1 %141, i64 %140, i64 %23
%143 = add nsw i64 %142, %132
store i64 %143, i64* %131
br label %144
144: ; preds = %125, %101
%145 = add nuw nsw i32 %104, 2
%146 = icmp slt i32 %145, %21
br i1 %146, label %101, label %147
147: ; preds = %144, %94
%148 = add nuw nsw i32 %96, 2
%149 = icmp slt i32 %148, %1
%150 = add i32 %95, %10
br i1 %149, label %94, label %85
151: ; preds = %86, %262
%152 = phi i32 [ %92, %86 ], [ %266, %262 ]
%153 = phi i32 [ %91, %86 ], [ %265, %262 ]
%154 = phi i32 [ 2, %86 ], [ %263, %262 ]
br i1 %88, label %155, label %262
155: ; preds = %151
%156 = sext i32 %152 to i64
%157 = sext i32 %153 to i64
br label %158
158: ; preds = %155, %257
%159 = phi i64 [ %156, %155 ], [ %258, %257 ]
%160 = phi i64 [ %157, %155 ], [ %259, %257 ]
%161 = phi i32 [ 2, %155 ], [ %260, %257 ]
%162 = sub nsw i64 %159, %93
%163 = add nsw i64 %162, -2
%164 = getelementptr inbounds i64, i64* %0, i64 %163
%165 = load i64, i64* %164
%166 = add nsw i64 %159, %93
%167 = add nsw i64 %166, -2
%168 = getelementptr inbounds i64, i64* %0, i64 %167
%169 = load i64, i64* %168
%170 = add nsw i64 %162, 2
%171 = getelementptr inbounds i64, i64* %0, i64 %170
%172 = load i64, i64* %171
%173 = add nsw i64 %166, 2
%174 = getelementptr inbounds i64, i64* %0, i64 %173
%175 = load i64, i64* %174
%176 = getelementptr inbounds i64, i64* %0, i64 %159
%177 = load i64, i64* %176
%178 = add i64 %169, %172
%179 = sub i64 %165, %178
%180 = add i64 %179, %175
%181 = getelementptr inbounds i64, i64* %0, i64 %160
%182 = load i64, i64* %181
%183 = shl i64 %182, 1
%184 = shl i64 %159, 32
%185 = ashr exact i64 %184, 32
%186 = or i64 %185, 1
%187 = getelementptr inbounds i64, i64* %0, i64 %186
%188 = load i64, i64* %187
%189 = shl i64 %188, 1
%190 = sub nsw i64 %175, %177
%191 = icmp sgt i64 %190, 0
%192 = select i1 %191, i64 %190, i64 0
%193 = add i64 %189, %183
%194 = sub i64 %192, %193
%195 = sub nsw i64 %177, %169
%196 = icmp sgt i64 %195, 0
%197 = select i1 %196, i64 %195, i64 0
%198 = add nsw i64 %197, %183
%199 = sub i64 %198, %189
%200 = icmp slt i64 %194, %199
%201 = select i1 %200, i64 %194, i64 %199
%202 = sub nsw i64 %177, %172
%203 = icmp sgt i64 %202, 0
%204 = select i1 %203, i64 %202, i64 0
%205 = sub nsw i64 %204, %183
%206 = sub nsw i64 %165, %177
%207 = icmp sgt i64 %206, 0
%208 = select i1 %207, i64 %206, i64 0
%209 = add nsw i64 %208, %183
%210 = icmp slt i64 %205, %209
%211 = select i1 %210, i64 %205, i64 %209
%212 = add nsw i64 %211, %189
%213 = icmp slt i64 %201, %212
%214 = select i1 %213, i64 %201, i64 %212
%215 = shl i64 %214, 4
%216 = icmp slt i64 %190, 0
%217 = select i1 %216, i64 %190, i64 0
%218 = sub i64 %217, %193
%219 = icmp slt i64 %195, 0
%220 = select i1 %219, i64 %195, i64 0
%221 = add nsw i64 %220, %183
%222 = sub i64 %221, %189
%223 = icmp sgt i64 %218, %222
%224 = select i1 %223, i64 %218, i64 %222
%225 = icmp slt i64 %202, 0
%226 = select i1 %225, i64 %202, i64 0
%227 = sub nsw i64 %226, %183
%228 = icmp slt i64 %206, 0
%229 = select i1 %228, i64 %206, i64 0
%230 = add nsw i64 %229, %183
%231 = icmp sgt i64 %227, %230
%232 = select i1 %231, i64 %227, i64 %230
%233 = add nsw i64 %232, %189
%234 = icmp sgt i64 %224, %233
%235 = select i1 %234, i64 %224, i64 %233
%236 = shl i64 %235, 4
%237 = icmp slt i64 %236, %215
br i1 %237, label %238, label %257
238: ; preds = %158
%239 = icmp slt i64 %180, %215
%240 = select i1 %239, i64 %180, i64 %215
%241 = icmp sgt i64 %240, %236
%242 = select i1 %241, i64 %240, i64 %236
%243 = add nsw i64 %160, 1
%244 = getelementptr inbounds i64, i64* %0, i64 %243
%245 = load i64, i64* %244
%246 = mul i64 %245, -64
%247 = add i64 %246, %242
%248 = icmp sgt i64 %247, -1
%249 = add nsw i64 %247, 63
%250 = select i1 %248, i64 %247, i64 %249
%251 = ashr i64 %250, 6
%252 = icmp slt i64 %251, %7
%253 = select i1 %252, i64 %251, i64 %7
%254 = icmp sgt i64 %253, %89
%255 = select i1 %254, i64 %253, i64 %89
%256 = add nsw i64 %255, %245
store i64 %256, i64* %244
br label %257
257: ; preds = %238, %158
%258 = add nsw i64 %159, 2
%259 = add nsw i64 %160, 2
%260 = add nuw nsw i32 %161, 2
%261 = icmp slt i32 %260, %87
br i1 %261, label %158, label %262
262: ; preds = %257, %151
%263 = add nuw nsw i32 %154, 2
%264 = icmp slt i32 %263, %11
%265 = add i32 %153, %10
%266 = add i32 %152, %10
br i1 %264, label %151, label %267
267: ; preds = %262, %85, %5
ret void
}