void hsmooth(int a[], int nxtop, int nytop, int ny, int scale) {
  int i, j;
  int ny2, s10, s00, diff, dmax, dmin, s, smax;
  int hm, h0, hp, hmm, hpm, hmp, hpp, hx2, hy2;
  int 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):
<hsmooth>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd8,%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
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jg     1134 <hsmooth+0x34>
jmp    1ee0 <hsmooth+0xde0>
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    1458 <hsmooth+0x358>
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    1445 <hsmooth+0x345>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jge    11da <hsmooth+0xda>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    11e3 <hsmooth+0xe3>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    $0x0,%eax
jle    1225 <hsmooth+0x125>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jge    1211 <hsmooth+0x111>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    121a <hsmooth+0x11a>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    122f <hsmooth+0x12f>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    122f <hsmooth+0x12f>
mov    -0x78(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jle    125a <hsmooth+0x15a>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    1263 <hsmooth+0x163>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    $0x0,%eax
jge    12a8 <hsmooth+0x1a8>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jle    1291 <hsmooth+0x191>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    129a <hsmooth+0x19a>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    12b5 <hsmooth+0x1b5>
xor    %eax,%eax
mov    %eax,-0x84(%rbp)
jmp    12b5 <hsmooth+0x1b5>
mov    -0x84(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1425 <hsmooth+0x325>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12e7 <hsmooth+0x1e7>
mov    -0x30(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    12f0 <hsmooth+0x1f0>
mov    -0x34(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1333 <hsmooth+0x233>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1319 <hsmooth+0x219>
mov    -0x30(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1322 <hsmooth+0x222>
mov    -0x34(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    133c <hsmooth+0x23c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x3,%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1376 <hsmooth+0x276>
mov    -0x3c(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x94(%rbp)
jmp    1385 <hsmooth+0x285>
mov    -0x3c(%rbp),%eax
add    $0x7,%eax
sar    $0x3,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    13a8 <hsmooth+0x2a8>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    13b1 <hsmooth+0x2b1>
mov    -0x40(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
xor    %ecx,%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jle    13f8 <hsmooth+0x2f8>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    13de <hsmooth+0x2de>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    13e7 <hsmooth+0x2e7>
mov    -0x40(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    1403 <hsmooth+0x303>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
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    116f <hsmooth+0x6f>
jmp    144a <hsmooth+0x34a>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1144 <hsmooth+0x44>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17b2 <hsmooth+0x6b2>
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    179f <hsmooth+0x69f>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jge    14fb <hsmooth+0x3fb>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    1507 <hsmooth+0x407>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    $0x0,%eax
jle    1558 <hsmooth+0x458>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jge    153b <hsmooth+0x43b>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    1547 <hsmooth+0x447>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1565 <hsmooth+0x465>
xor    %eax,%eax
mov    %eax,-0xac(%rbp)
jmp    1565 <hsmooth+0x465>
mov    -0xac(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jle    1596 <hsmooth+0x496>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xb0(%rbp)
jmp    15a2 <hsmooth+0x4a2>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    $0x0,%eax
jge    15f3 <hsmooth+0x4f3>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jle    15d6 <hsmooth+0x4d6>
mov    -0x4c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    15e2 <hsmooth+0x4e2>
mov    -0x48(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    1600 <hsmooth+0x500>
xor    %eax,%eax
mov    %eax,-0xb8(%rbp)
jmp    1600 <hsmooth+0x500>
mov    -0xb8(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    177f <hsmooth+0x67f>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1632 <hsmooth+0x532>
mov    -0x30(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    163b <hsmooth+0x53b>
mov    -0x34(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    167e <hsmooth+0x57e>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1664 <hsmooth+0x564>
mov    -0x30(%rbp),%eax
mov    %eax,-0xc0(%rbp)
jmp    166d <hsmooth+0x56d>
mov    -0x34(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    1687 <hsmooth+0x587>
mov    -0x38(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x3,%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     16c6 <hsmooth+0x5c6>
mov    -0x3c(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0xc8(%rbp)
jmp    16d5 <hsmooth+0x5d5>
mov    -0x3c(%rbp),%eax
add    $0x7,%eax
sar    $0x3,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    16f8 <hsmooth+0x5f8>
mov    -0x3c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    1701 <hsmooth+0x601>
mov    -0x40(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
xor    %ecx,%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jle    1748 <hsmooth+0x648>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    172e <hsmooth+0x62e>
mov    -0x3c(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    1737 <hsmooth+0x637>
mov    -0x40(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    1753 <hsmooth+0x653>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
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    1488 <hsmooth+0x388>
jmp    17a4 <hsmooth+0x6a4>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    145f <hsmooth+0x35f>
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1ee0 <hsmooth+0xde0>
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    1ecd <hsmooth+0xdcd>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jle    18b4 <hsmooth+0x7b4>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    18c1 <hsmooth+0x7c1>
xor    %eax,%eax
mov    %eax,-0xd8(%rbp)
jmp    18c1 <hsmooth+0x7c1>
mov    -0xd8(%rbp),%eax
sub    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jle    18f3 <hsmooth+0x7f3>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0xe0(%rbp)
jmp    1900 <hsmooth+0x800>
xor    %eax,%eax
mov    %eax,-0xe0(%rbp)
jmp    1900 <hsmooth+0x800>
mov    -0xdc(%rbp),%eax
mov    -0xe0(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    -0x64(%rbp),%ecx
cmp    %ecx,%eax
jge    195e <hsmooth+0x85e>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jle    193a <hsmooth+0x83a>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1947 <hsmooth+0x847>
xor    %eax,%eax
mov    %eax,-0xe4(%rbp)
jmp    1947 <hsmooth+0x847>
mov    -0xe4(%rbp),%eax
sub    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    199d <hsmooth+0x89d>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jle    197e <hsmooth+0x87e>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0xec(%rbp)
jmp    198b <hsmooth+0x88b>
xor    %eax,%eax
mov    %eax,-0xec(%rbp)
jmp    198b <hsmooth+0x88b>
mov    -0xec(%rbp),%eax
add    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jle    19c6 <hsmooth+0x8c6>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xf0(%rbp)
jmp    19d3 <hsmooth+0x8d3>
xor    %eax,%eax
mov    %eax,-0xf0(%rbp)
jmp    19d3 <hsmooth+0x8d3>
mov    -0xf0(%rbp),%eax
sub    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jle    1a05 <hsmooth+0x905>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    1a12 <hsmooth+0x912>
xor    %eax,%eax
mov    %eax,-0xf8(%rbp)
jmp    1a12 <hsmooth+0x912>
mov    -0xf4(%rbp),%eax
mov    -0xf8(%rbp),%ecx
add    -0x60(%rbp),%ecx
add    -0x64(%rbp),%ecx
cmp    %ecx,%eax
jge    1a70 <hsmooth+0x970>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jle    1a4c <hsmooth+0x94c>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1a59 <hsmooth+0x959>
xor    %eax,%eax
mov    %eax,-0xfc(%rbp)
jmp    1a59 <hsmooth+0x959>
mov    -0xfc(%rbp),%eax
sub    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x100(%rbp)
jmp    1aaf <hsmooth+0x9af>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jle    1a90 <hsmooth+0x990>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    1a9d <hsmooth+0x99d>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    1a9d <hsmooth+0x99d>
mov    -0x104(%rbp),%eax
add    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1ad2 <hsmooth+0x9d2>
mov    -0x68(%rbp),%eax
mov    %eax,-0x108(%rbp)
jmp    1adb <hsmooth+0x9db>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x34(%rbp)
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jge    1b07 <hsmooth+0xa07>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    1b14 <hsmooth+0xa14>
xor    %eax,%eax
mov    %eax,-0x10c(%rbp)
jmp    1b14 <hsmooth+0xa14>
mov    -0x10c(%rbp),%eax
sub    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jge    1b46 <hsmooth+0xa46>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x114(%rbp)
jmp    1b53 <hsmooth+0xa53>
xor    %eax,%eax
mov    %eax,-0x114(%rbp)
jmp    1b53 <hsmooth+0xa53>
mov    -0x110(%rbp),%eax
mov    -0x114(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    -0x64(%rbp),%ecx
cmp    %ecx,%eax
jle    1bb1 <hsmooth+0xab1>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jge    1b8d <hsmooth+0xa8d>
mov    -0x5c(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x118(%rbp)
jmp    1b9a <hsmooth+0xa9a>
xor    %eax,%eax
mov    %eax,-0x118(%rbp)
jmp    1b9a <hsmooth+0xa9a>
mov    -0x118(%rbp),%eax
sub    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    1bf0 <hsmooth+0xaf0>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jge    1bd1 <hsmooth+0xad1>
mov    -0x48(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x120(%rbp)
jmp    1bde <hsmooth+0xade>
xor    %eax,%eax
mov    %eax,-0x120(%rbp)
jmp    1bde <hsmooth+0xade>
mov    -0x120(%rbp),%eax
add    -0x60(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jge    1c19 <hsmooth+0xb19>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x124(%rbp)
jmp    1c26 <hsmooth+0xb26>
xor    %eax,%eax
mov    %eax,-0x124(%rbp)
jmp    1c26 <hsmooth+0xb26>
mov    -0x124(%rbp),%eax
sub    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jge    1c58 <hsmooth+0xb58>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    1c65 <hsmooth+0xb65>
xor    %eax,%eax
mov    %eax,-0x12c(%rbp)
jmp    1c65 <hsmooth+0xb65>
mov    -0x128(%rbp),%eax
mov    -0x12c(%rbp),%ecx
add    -0x60(%rbp),%ecx
add    -0x64(%rbp),%ecx
cmp    %ecx,%eax
jle    1cc3 <hsmooth+0xbc3>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jge    1c9f <hsmooth+0xb9f>
mov    -0x48(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    1cac <hsmooth+0xbac>
xor    %eax,%eax
mov    %eax,-0x130(%rbp)
jmp    1cac <hsmooth+0xbac>
mov    -0x130(%rbp),%eax
sub    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x134(%rbp)
jmp    1d02 <hsmooth+0xc02>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
jge    1ce3 <hsmooth+0xbe3>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x138(%rbp)
jmp    1cf0 <hsmooth+0xbf0>
xor    %eax,%eax
mov    %eax,-0x138(%rbp)
jmp    1cf0 <hsmooth+0xbf0>
mov    -0x138(%rbp),%eax
add    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jle    1d25 <hsmooth+0xc25>
mov    -0x68(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    1d2e <hsmooth+0xc2e>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1ead <hsmooth+0xdad>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1d60 <hsmooth+0xc60>
mov    -0x30(%rbp),%eax
mov    %eax,-0x140(%rbp)
jmp    1d69 <hsmooth+0xc69>
mov    -0x34(%rbp),%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1dac <hsmooth+0xcac>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1d92 <hsmooth+0xc92>
mov    -0x30(%rbp),%eax
mov    %eax,-0x144(%rbp)
jmp    1d9b <hsmooth+0xc9b>
mov    -0x34(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
mov    %eax,-0x148(%rbp)
jmp    1db5 <hsmooth+0xcb5>
mov    -0x38(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1df4 <hsmooth+0xcf4>
mov    -0x3c(%rbp),%eax
sar    $0x6,%eax
mov    %eax,-0x14c(%rbp)
jmp    1e03 <hsmooth+0xd03>
mov    -0x3c(%rbp),%eax
add    $0x3f,%eax
sar    $0x6,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1e26 <hsmooth+0xd26>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    1e2f <hsmooth+0xd2f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
xor    %ecx,%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jle    1e76 <hsmooth+0xd76>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1e5c <hsmooth+0xd5c>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    1e65 <hsmooth+0xd65>
mov    -0x40(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    1e81 <hsmooth+0xd81>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
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    17e7 <hsmooth+0x6e7>
jmp    1ed2 <hsmooth+0xdd2>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    17b9 <hsmooth+0x6b9>
add    $0xd8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hsmooth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rdx,-0x70(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %r8d,-0x80(%rsp)
cmp    $0x2,%r8d
jl     15cb <hsmooth+0x4cb>
sarl   -0x80(%rsp)
mov    %rcx,-0x58(%rsp)
lea    (%rcx,%rcx,1),%eax
lea    -0x2(%rsi),%ecx
mov    %ecx,-0x5c(%rsp)
mov    %eax,-0x7c(%rsp)
cltq
mov    %rax,-0x48(%rsp)
mov    %rsi,-0x40(%rsp)
cmp    $0x5,%esi
jl     1276 <hsmooth+0x176>
mov    -0x80(%rsp),%r13d
neg    %r13d
mov    -0x58(%rsp),%rax
lea    (%rax,%rax,2),%esi
mov    -0x48(%rsp),%rax
lea    0x0(,%rax,4),%rcx
mov    -0x78(%rsp),%rdx
mov    %rcx,%rax
mov    %rcx,-0x50(%rsp)
sub    %rcx,%rdx
mov    %rdx,-0x38(%rsp)
mov    $0x2,%r15d
xor    %r12d,%r12d
mov    -0x7c(%rsp),%r14d
jmp    11b8 <hsmooth+0xb8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%r15d
mov    -0x7c(%rsp),%eax
add    %eax,%esi
add    %eax,%r14d
cmp    -0x5c(%rsp),%r15d
jge    1276 <hsmooth+0x176>
cmpl   $0x0,-0x70(%rsp)
jle    11a0 <hsmooth+0xa0>
movslq %r14d,%rax
mov    -0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%r8
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
movslq %esi,%rax
lea    (%rcx,%rax,4),%r10
mov    -0x50(%rsp),%rax
lea    (%rbx,%rax,1),%rbp
xor    %eax,%eax
jmp    1200 <hsmooth+0x100>
nopl   0x0(%rax,%rax,1)
add    %ecx,%edx
mov    %edx,(%r10,%rax,4)
add    $0x2,%rax
cmp    -0x70(%rsp),%eax
jge    11a0 <hsmooth+0xa0>
mov    (%r8,%rax,4),%r9d
mov    (%rbx,%rax,4),%ecx
mov    0x0(%rbp,%rax,4),%edi
mov    %edi,%edx
sub    %ecx,%edx
sub    %r9d,%ecx
cmp    %ecx,%edx
mov    %ecx,%r11d
cmovl  %edx,%r11d
cmovg  %edx,%ecx
test   %r11d,%r11d
cmovs  %r12d,%r11d
shl    $0x2,%r11d
mov    %ecx,%edx
sar    $0x1f,%edx
and    %ecx,%edx
shl    $0x2,%edx
cmp    %r11d,%edx
jge    11f6 <hsmooth+0xf6>
sub    %r9d,%edi
cmp    %r11d,%edi
cmovge %r11d,%edi
cmp    %edx,%edi
cmovle %edx,%edi
mov    (%r10,%rax,4),%ecx
lea    0x0(,%rcx,8),%edx
sub    %edx,%edi
lea    0x7(%rdi),%edx
test   %edi,%edi
cmovns %edi,%edx
sar    $0x3,%edx
cmp    -0x80(%rsp),%edx
jl     1269 <hsmooth+0x169>
mov    -0x80(%rsp),%edx
cmp    %r13d,%edx
jg     11f0 <hsmooth+0xf0>
mov    %r13d,%edx
jmp    11f0 <hsmooth+0xf0>
mov    -0x40(%rsp),%r15
test   %r15d,%r15d
jle    1359 <hsmooth+0x259>
mov    -0x70(%rsp),%rax
lea    -0x2(%rax),%r14d
mov    -0x80(%rsp),%r8d
neg    %r8d
xor    %r11d,%r11d
mov    $0x2,%r9d
xor    %r10d,%r10d
jmp    12c2 <hsmooth+0x1c2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%r10d
add    -0x7c(%rsp),%r9d
cmp    %r15d,%r10d
jge    1359 <hsmooth+0x259>
cmpl   $0x5,-0x70(%rsp)
jl     12b0 <hsmooth+0x1b0>
movslq %r9d,%rax
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    (%rcx,%rax,4),%ebx
mov    $0x2,%edx
jmp    12ef <hsmooth+0x1ef>
nop
add    %ecx,%ebp
mov    %ebp,-0x4(%rdi,%rdx,4)
add    $0x2,%rdx
cmp    %r14d,%edx
jge    12b0 <hsmooth+0x1b0>
mov    %ebx,%esi
mov    -0x10(%rdi,%rdx,4),%ecx
mov    (%rdi,%rdx,4),%ebx
mov    %ebx,%eax
sub    %esi,%eax
sub    %ecx,%esi
cmp    %esi,%eax
mov    %esi,%ebp
cmovl  %eax,%ebp
cmovg  %eax,%esi
test   %ebp,%ebp
cmovs  %r11d,%ebp
shl    $0x2,%ebp
mov    %esi,%eax
sar    $0x1f,%eax
and    %esi,%eax
shl    $0x2,%eax
cmp    %ebp,%eax
jge    12e6 <hsmooth+0x1e6>
mov    %ebx,%esi
sub    %ecx,%esi
cmp    %ebp,%esi
cmovge %ebp,%esi
cmp    %eax,%esi
cmovle %eax,%esi
mov    -0x4(%rdi,%rdx,4),%ecx
lea    0x0(,%rcx,8),%eax
sub    %eax,%esi
lea    0x7(%rsi),%ebp
test   %esi,%esi
cmovns %esi,%ebp
sar    $0x3,%ebp
cmp    -0x80(%rsp),%ebp
jl     134f <hsmooth+0x24f>
mov    -0x80(%rsp),%ebp
cmp    %r8d,%ebp
jg     12e0 <hsmooth+0x1e0>
mov    %r8d,%ebp
jmp    12e0 <hsmooth+0x1e0>
cmp    $0x5,%r15d
mov    -0x58(%rsp),%rcx
jl     15cb <hsmooth+0x4cb>
mov    -0x70(%rsp),%rax
add    $0xfffffffe,%eax
mov    %eax,-0x24(%rsp)
mov    -0x80(%rsp),%eax
neg    %eax
mov    %eax,-0x28(%rsp)
lea    (%rcx,%rcx,2),%eax
add    $0x2,%eax
mov    %eax,-0x60(%rsp)
mov    -0x48(%rsp),%rcx
lea    0x2(%rcx),%eax
mov    %eax,-0x64(%rsp)
mov    $0x2,%eax
sub    %rcx,%rax
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x10(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,-0x18(%rsp)
lea    0x4(%rcx),%rax
mov    %rax,-0x20(%rsp)
mov    $0x2,%ecx
jmp    13ed <hsmooth+0x2ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x2c(%rsp),%ecx
add    $0x2,%ecx
mov    -0x7c(%rsp),%eax
add    %eax,-0x60(%rsp)
add    %eax,-0x64(%rsp)
cmp    -0x5c(%rsp),%ecx
jge    15cb <hsmooth+0x4cb>
mov    %ecx,-0x2c(%rsp)
cmpl   $0x5,-0x70(%rsp)
jl     13d0 <hsmooth+0x2d0>
movslq -0x64(%rsp),%r15
mov    -0x48(%rsp),%rax
add    %r15,%rax
mov    -0x10(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
mov    %rcx,0x8(%rsp)
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
mov    %rcx,(%rsp)
shl    $0x20,%r15
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x8(%rsp)
movslq -0x60(%rsp),%rax
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x50(%rsp)
xor    %r11d,%r11d
jmp    146f <hsmooth+0x36f>
nopw   0x0(%rax,%rax,1)
movabs $0x200000000,%rax
add    %rax,%r15
add    $0x2,%r11
lea    0x2(%r11),%eax
cmp    -0x24(%rsp),%eax
jge    13d0 <hsmooth+0x2d0>
mov    0x8(%rsp),%rax
mov    -0x10(%rax,%r11,4),%r13d
mov    (%rax,%r11,4),%r10d
mov    -0x8(%rsp),%rax
mov    -0x10(%rax,%r11,4),%r9d
mov    (%rax,%r11,4),%ebx
mov    (%rsp),%rax
mov    (%rax,%r11,4),%ecx
mov    -0x50(%rsp),%rax
mov    -0x4(%rax,%r11,4),%esi
lea    (%rsi,%rsi,1),%eax
mov    %r15,%rdx
sar    $0x1e,%rdx
or     $0x4,%rdx
mov    -0x78(%rsp),%rdi
mov    (%rdi,%rdx,1),%edi
lea    (%rdi,%rdi,1),%r14d
mov    %ebx,-0x38(%rsp)
sub    %ecx,%ebx
mov    $0x0,%ebp
cmovns %ebx,%ebp
lea    (%rax,%rdi,2),%r12d
sub    %r12d,%ebp
mov    %ecx,%r8d
mov    %r9d,-0x58(%rsp)
sub    %r9d,%r8d
mov    $0x0,%edx
cmovns %r8d,%edx
lea    (%rdx,%rsi,2),%edx
sub    %r14d,%edx
cmp    %edx,%ebp
cmovl  %ebp,%edx
mov    %ecx,%r9d
mov    %r10d,-0x40(%rsp)
sub    %r10d,%r9d
mov    $0x0,%ebp
cmovns %r9d,%ebp
sub    %eax,%ebp
mov    %r13d,%r10d
sub    %ecx,%r10d
mov    $0x0,%ecx
cmovns %r10d,%ecx
lea    (%rcx,%rsi,2),%ecx
cmp    %ecx,%ebp
cmovge %ecx,%ebp
lea    0x0(%rbp,%rdi,2),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %ebx,%ecx
sar    $0x1f,%ecx
and    %ebx,%ecx
sub    %r12d,%ecx
mov    %r8d,%ebx
sar    $0x1f,%ebx
and    %r8d,%ebx
lea    (%rbx,%rsi,2),%ebx
sub    %r14d,%ebx
shl    $0x4,%edx
cmp    %ebx,%ecx
cmovg  %ecx,%ebx
mov    %r9d,%ecx
sar    $0x1f,%ecx
and    %r9d,%ecx
sub    %eax,%ecx
mov    %r10d,%eax
sar    $0x1f,%eax
and    %r10d,%eax
lea    (%rax,%rsi,2),%eax
cmp    %eax,%ecx
cmovle %eax,%ecx
lea    (%rcx,%rdi,2),%eax
cmp    %eax,%ebx
cmovle %eax,%ebx
shl    $0x4,%ebx
cmp    %edx,%ebx
jge    1450 <hsmooth+0x350>
mov    -0x58(%rsp),%eax
add    -0x40(%rsp),%eax
sub    %eax,%r13d
add    -0x38(%rsp),%r13d
cmp    %edx,%r13d
cmovge %edx,%r13d
cmp    %ebx,%r13d
cmovle %ebx,%r13d
mov    -0x50(%rsp),%rsi
mov    (%rsi,%r11,4),%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%r13d
lea    0x3f(%r13),%ecx
test   %r13d,%r13d
cmovns %r13d,%ecx
sar    $0x6,%ecx
mov    -0x80(%rsp),%edx
cmp    %edx,%ecx
cmovge %edx,%ecx
mov    -0x28(%rsp),%edx
cmp    %edx,%ecx
cmovle %edx,%ecx
add    %eax,%ecx
mov    %ecx,(%rsi,%r11,4)
jmp    1450 <hsmooth+0x350>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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