void tempofilt(unsigned char *rmap1, int nt, int ny, int nx, int N,
               unsigned char *cmap, int *offset, int *step) {
  int l, imgsize, it, **done, **appear, iy, ix, i;
  unsigned char *rmap0, *rmap;
  short *rmap2, *rmap3;
  float *J;
  imgsize = ny * nx;
  rmap2 = (short *)calloc(imgsize, sizeof(short));
  rmap3 = (short *)calloc(imgsize, sizeof(short));
  rmap0 = (unsigned char *)calloc(imgsize, sizeof(unsigned char));
  for (l = 0; l < imgsize; l++)
    rmap0[l] = 1;
  J = (float *)calloc(imgsize, sizeof(float));
  done = (int **)imatrix(1, 2);
  appear = (int **)imatrix(nt, 256);
  rmap = rmap1;
  for (it = 0; it < nt; it++) {
    for (l = 0; l < imgsize; l++)
      appear[it][rmap[l]] = 1;
    rmap += imgsize;
  }
  rmap = rmap1;
  for (l = 0; l < imgsize; l++) {
    if (rmap[l] == 0)
      break;
  }
  if (l < imgsize) {
    for (l = 0; l < imgsize; l++)
      rmap2[l] = rmap[l];
    getJ(cmap, N, ny, nx, J, offset[1], step[1], rmap2, rmap0, 1);
    removehole(rmap2, 1, ny, nx, rmap0);
    done[0][1] = 0;
    flood(rmap2, J, 1, ny, nx, rmap0, 1, done);
    for (l = 0; l < imgsize; l++)
      rmap[l] = (unsigned char)rmap2[l];
  }
  for (it = 1; it < nt - 1; it++) {
    if (it < nt - 2) {
      rmap = rmap1 + (it + 1) * imgsize;
      for (l = 0; l < imgsize; l++) {
        if (rmap[l] != rmap[l + imgsize] && rmap[l] != rmap[l - imgsize])
          rmap3[l] = 0;
        else
          rmap3[l] = rmap[l];
      }
    }
    rmap = rmap1 + it * imgsize;
    for (l = 0; l < imgsize; l++) {
      if (rmap[l - imgsize] == rmap3[l] && rmap[l - imgsize] > 0) {
        if (appear[it - 1][rmap[l]] && appear[it + 1][rmap[l]])
          rmap[l] = rmap[l - imgsize];
      }
    }
    for (l = 0; l < imgsize; l++) {
      if (rmap[l] > 0) {
        if (rmap[l] != rmap[l - imgsize] && appear[it - 1][rmap[l]])
          rmap[l] = 0;
        else if (rmap[l] != rmap[l + imgsize] && appear[it + 1][rmap[l]])
          rmap[l] = 0;
      }
    }
    for (l = 0; l < imgsize; l++)
      rmap2[l] = rmap[l];
    l = 0;
    for (iy = 0; iy < ny; iy++) {
      for (ix = 0; ix < nx; ix++) {
        if (rmap[l] > 0) {
          if (iy - 1 >= 0) {
            if (rmap[l - nx] == 0)
              rmap2[l] = 0;
          }
          if (ix - 1 >= 0) {
            if (rmap[l - 1] == 0)
              rmap2[l] = 0;
          }
          if (ix + 1 < nx) {
            if (rmap[l + 1] == 0)
              rmap2[l] = 0;
          }
          if (iy + 1 < ny) {
            if (rmap[l + nx] == 0)
              rmap2[l] = 0;
          }
        }
        l++;
      }
    }
    getJ(cmap + it * imgsize, N, ny, nx, J, offset[1], step[1], rmap2, rmap0,
         1);
    removehole(rmap2, 1, ny, nx, rmap0);
    done[0][1] = 0;
    flood(rmap2, J, 1, ny, nx, rmap0, 1, done);
    for (l = 0; l < imgsize; l++)
      rmap[l] = (unsigned char)rmap2[l];
  }
  rmap = rmap1 + (nt - 1) * imgsize;
  for (l = 0; l < imgsize; l++) {
    if (rmap[l] == 0)
      break;
  }
  if (l < imgsize) {
    for (l = 0; l < imgsize; l++)
      rmap2[l] = rmap[l];
    getJ(cmap + it * imgsize, N, ny, nx, J, offset[1], step[1], rmap2, rmap0,
         1);
    removehole(rmap2, 1, ny, nx, rmap0);
    done[0][1] = 0;
    flood(rmap2, J, 1, ny, nx, rmap0, 1, done);
    for (l = 0; l < imgsize; l++)
      rmap[l] = (unsigned char)rmap2[l];
  }
  free_imatrix(appear, nt);
  free(rmap0);
  free(rmap2);
  free(rmap3);
  free(J);
  free_imatrix(done, 1);
}


x86 assembly (clang, -O0):
<tempofilt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
movslq -0x28(%rbp),%rdi
mov    $0x2,%esi
call   1060 <calloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x28(%rbp),%rdi
mov    $0x2,%esi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x28(%rbp),%rdi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1205 <tempofilt+0x95>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11df <tempofilt+0x6f>
movslq -0x28(%rbp),%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    $0x1,%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1050 <imatrix@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x100,%esi
mov    $0x0,%al
call   1050 <imatrix@plt>
cltq
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12bd <tempofilt+0x14d>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    129e <tempofilt+0x12e>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1265 <tempofilt+0xf5>
mov    -0x28(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1252 <tempofilt+0xe2>
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1305 <tempofilt+0x195>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    12f2 <tempofilt+0x182>
jmp    1305 <tempofilt+0x195>
jmp    12f7 <tempofilt+0x187>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12cc <tempofilt+0x15c>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1429 <tempofilt+0x2b9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    134d <tempofilt+0x1dd>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1318 <tempofilt+0x1a8>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x78(%rbp),%r8
mov    0x10(%rbp),%rax
mov    0x4(%rax),%r9d
mov    0x18(%rbp),%rax
mov    0x4(%rax),%r11d
mov    -0x68(%rbp),%r10
mov    -0x58(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x1,0x18(%rsp)
mov    $0x0,%al
call   1030 <getJ@plt>
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%r8
mov    $0x1,%esi
mov    $0x0,%al
call   1080 <removehole@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movl   $0x0,0x4(%rax)
mov    -0x68(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x38(%rbp),%rax
mov    $0x1,%edx
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1090 <flood@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1424 <tempofilt+0x2b4>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f1 <tempofilt+0x281>
jmp    1429 <tempofilt+0x2b9>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1982 <tempofilt+0x812>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    150d <tempofilt+0x39d>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1508 <tempofilt+0x398>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x60(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     14da <tempofilt+0x36a>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x60(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     14da <tempofilt+0x36a>
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    14f5 <tempofilt+0x385>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    14fa <tempofilt+0x38a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1471 <tempofilt+0x301>
jmp    150d <tempofilt+0x39d>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15f5 <tempofilt+0x485>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x70(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jne    15e2 <tempofilt+0x472>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jle    15e2 <tempofilt+0x472>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmpl   $0x0,(%rax,%rcx,4)
je     15dd <tempofilt+0x46d>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmpl   $0x0,(%rax,%rcx,4)
je     15dd <tempofilt+0x46d>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    15e2 <tempofilt+0x472>
jmp    15e7 <tempofilt+0x477>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1529 <tempofilt+0x3b9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    16ef <tempofilt+0x57f>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jle    16dc <tempofilt+0x56c>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x60(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     167a <tempofilt+0x50a>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmpl   $0x0,(%rax,%rcx,4)
je     167a <tempofilt+0x50a>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    16d7 <tempofilt+0x567>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x60(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     16d2 <tempofilt+0x562>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmpl   $0x0,(%rax,%rcx,4)
je     16d2 <tempofilt+0x562>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    16d7 <tempofilt+0x567>
jmp    16dc <tempofilt+0x56c>
jmp    16e1 <tempofilt+0x571>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15fc <tempofilt+0x48c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    172b <tempofilt+0x5bb>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16f6 <tempofilt+0x586>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    188c <tempofilt+0x71c>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1879 <tempofilt+0x709>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jle    1862 <tempofilt+0x6f2>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     17a9 <tempofilt+0x639>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    17a4 <tempofilt+0x634>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    17a9 <tempofilt+0x639>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     17e5 <tempofilt+0x675>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    17e0 <tempofilt+0x670>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    17e5 <tempofilt+0x675>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jge    1821 <tempofilt+0x6b1>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    181c <tempofilt+0x6ac>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    1821 <tempofilt+0x6b1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jge    185d <tempofilt+0x6ed>
mov    -0x60(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1858 <tempofilt+0x6e8>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    185d <tempofilt+0x6ed>
jmp    1862 <tempofilt+0x6f2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    174c <tempofilt+0x5dc>
jmp    187e <tempofilt+0x70e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1739 <tempofilt+0x5c9>
mov    -0x20(%rbp),%rdi
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
cltq
add    %rax,%rdi
mov    -0x18(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x78(%rbp),%r8
mov    0x10(%rbp),%rax
mov    0x4(%rax),%r9d
mov    0x18(%rbp),%rax
mov    0x4(%rax),%r11d
mov    -0x68(%rbp),%r10
mov    -0x58(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x1,0x18(%rsp)
mov    $0x0,%al
call   1030 <getJ@plt>
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%r8
mov    $0x1,%esi
mov    $0x0,%al
call   1080 <removehole@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movl   $0x0,0x4(%rax)
mov    -0x68(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x38(%rbp),%rax
mov    $0x1,%edx
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1090 <flood@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    196f <tempofilt+0x7ff>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    193c <tempofilt+0x7cc>
jmp    1974 <tempofilt+0x804>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1430 <tempofilt+0x2c0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    19da <tempofilt+0x86a>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    19c7 <tempofilt+0x857>
jmp    19da <tempofilt+0x86a>
jmp    19cc <tempofilt+0x85c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19a1 <tempofilt+0x831>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b0a <tempofilt+0x99a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a22 <tempofilt+0x8b2>
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19ed <tempofilt+0x87d>
mov    -0x20(%rbp),%rdi
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
cltq
add    %rax,%rdi
mov    -0x18(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x78(%rbp),%r8
mov    0x10(%rbp),%rax
mov    0x4(%rax),%r9d
mov    0x18(%rbp),%rax
mov    0x4(%rax),%r11d
mov    -0x68(%rbp),%r10
mov    -0x58(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x1,0x18(%rsp)
mov    $0x0,%al
call   1030 <getJ@plt>
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%r8
mov    $0x1,%esi
mov    $0x0,%al
call   1080 <removehole@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movl   $0x0,0x4(%rax)
mov    -0x68(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x38(%rbp),%rax
mov    $0x1,%edx
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1090 <flood@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b05 <tempofilt+0x995>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ad2 <tempofilt+0x962>
jmp    1b0a <tempofilt+0x99a>
mov    -0x40(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1070 <free_imatrix@plt>
mov    -0x58(%rbp),%rdi
call   1040 <free@plt>
mov    -0x68(%rbp),%rdi
call   1040 <free@plt>
mov    -0x70(%rbp),%rdi
call   1040 <free@plt>
mov    -0x78(%rbp),%rdi
call   1040 <free@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1070 <free_imatrix@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tempofilt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,0x68(%rsp)
mov    %r8d,0x24(%rsp)
mov    %ecx,%r13d
mov    %edx,%r12d
mov    %esi,%r14d
mov    %rdi,0x10(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    %ecx,%ebx
imul   %edx,%ebx
movslq %ebx,%rbp
mov    $0x2,%esi
mov    %rbp,%rdi
call   1070 <calloc@plt>
mov    %rax,0x8(%rsp)
mov    $0x2,%esi
mov    %rbp,%rdi
call   1070 <calloc@plt>
mov    %rax,0x70(%rsp)
mov    $0x1,%esi
mov    %rbp,%rdi
call   1070 <calloc@plt>
mov    %rax,%r15
mov    %rbp,0x40(%rsp)
test   %ebp,%ebp
jle    1217 <tempofilt+0x97>
mov    %ebx,%edx
mov    %r15,%rdi
mov    $0x1,%esi
call   1060 <memset@plt>
mov    %r15,0x30(%rsp)
mov    %ebx,0x4(%rsp)
mov    $0x4,%esi
mov    0x40(%rsp),%rdi
call   1070 <calloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1050 <imatrix@plt>
mov    %eax,%r15d
mov    %r14d,%edi
mov    $0x100,%esi
xor    %eax,%eax
call   1050 <imatrix@plt>
movslq %eax,%rdi
test   %r14d,%r14d
jle    1329 <tempofilt+0x1a9>
mov    %r14d,%r9d
mov    0x4(%rsp),%eax
mov    %eax,%r8d
add    $0xffffffffffffffff,%r8
mov    %eax,%edx
and    $0x3,%edx
mov    %eax,%r11d
and    $0xfffffffc,%r11d
xor    %r10d,%r10d
mov    0x10(%rsp),%rbp
jmp    12a2 <tempofilt+0x122>
nopw   0x0(%rax,%rax,1)
add    0x40(%rsp),%rbp
add    $0x1,%r10
cmp    %r9,%r10
je     1329 <tempofilt+0x1a9>
cmpl   $0x0,0x4(%rsp)
jle    1290 <tempofilt+0x110>
mov    (%rdi,%r10,8),%rbx
xor    %ecx,%ecx
cmp    $0x3,%r8
jb     12f9 <tempofilt+0x179>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%rbp,%rcx,1),%eax
movl   $0x1,(%rbx,%rax,4)
movzbl 0x1(%rbp,%rcx,1),%eax
movl   $0x1,(%rbx,%rax,4)
movzbl 0x2(%rbp,%rcx,1),%eax
movl   $0x1,(%rbx,%rax,4)
movzbl 0x3(%rbp,%rcx,1),%eax
movl   $0x1,(%rbx,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    12c0 <tempofilt+0x140>
test   %rdx,%rdx
je     1290 <tempofilt+0x110>
add    %rbp,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rcx,%rax,1),%esi
movl   $0x1,(%rbx,%rsi,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1310 <tempofilt+0x190>
jmp    1290 <tempofilt+0x110>
mov    %r14,0x50(%rsp)
movslq %r15d,%rax
mov    %rax,0x38(%rsp)
mov    0x4(%rsp),%esi
test   %esi,%esi
mov    0x8(%rsp),%rbx
mov    %rdi,0x28(%rsp)
mov    0x10(%rsp),%r15
mov    0x30(%rsp),%r11
jle    15c1 <tempofilt+0x441>
mov    %esi,%r14d
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,(%r15,%rax,1)
je     1375 <tempofilt+0x1f5>
add    $0x1,%rax
cmp    %rax,%r14
jne    1360 <tempofilt+0x1e0>
jmp    15c1 <tempofilt+0x441>
cmp    $0x10,%esi
jae    1381 <tempofilt+0x201>
xor    %eax,%eax
jmp    1430 <tempofilt+0x2b0>
mov    %r14d,%eax
and    $0xfffffff0,%eax
lea    -0x10(%rax),%rcx
mov    %rcx,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2075 <tempofilt+0xef5>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movq   (%r15,%rcx,1),%xmm1
movq   0x8(%r15,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rcx,2)
movdqu %xmm2,0x10(%rbx,%rcx,2)
movq   0x10(%r15,%rcx,1),%xmm1
movq   0x18(%r15,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%rbx,%rcx,2)
movdqu %xmm2,0x30(%rbx,%rcx,2)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13b0 <tempofilt+0x230>
test   $0x1,%dl
je     1425 <tempofilt+0x2a5>
movq   (%r15,%rcx,1),%xmm0
movq   0x8(%r15,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rcx,2)
movdqu %xmm1,0x10(%rbx,%rcx,2)
cmp    %r14,%rax
je     1442 <tempofilt+0x2c2>
nopw   0x0(%rax,%rax,1)
movzbl (%r15,%rax,1),%ecx
mov    %cx,(%rbx,%rax,2)
add    $0x1,%rax
cmp    %rax,%r14
jne    1430 <tempofilt+0x2b0>
mov    0x58(%rsp),%rax
mov    0x4(%rax),%r9d
mov    0x60(%rsp),%rax
mov    0x4(%rax),%r10d
xor    %ebp,%ebp
mov    0x68(%rsp),%rdi
mov    0x24(%rsp),%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    0x18(%rsp),%r8
xor    %eax,%eax
push   $0x1
push   %r11
push   %rbx
push   %r10
mov    %r11,%r15
call   1030 <getJ@plt>
add    $0x20,%rsp
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15,%r8
xor    %eax,%eax
call   1090 <removehole@plt>
mov    0x38(%rsp),%rbx
mov    (%rbx),%rax
movl   $0x0,0x4(%rax)
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    $0x1,%edx
mov    %r12d,%ecx
mov    %r13d,%r8d
mov    %r15,%r9
xor    %eax,%eax
push   %rbx
push   $0x1
call   10a0 <flood@plt>
add    $0x10,%rsp
mov    0x4(%rsp),%esi
cmp    $0x10,%esi
jae    14e9 <tempofilt+0x369>
mov    0x8(%rsp),%rbx
mov    0x28(%rsp),%rdi
mov    0x10(%rsp),%r15
jmp    15b0 <tempofilt+0x430>
mov    %r14d,%ebp
and    $0xfffffff0,%ebp
lea    -0x10(%rbp),%rax
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
test   %rax,%rax
mov    0x28(%rsp),%rdi
je     2085 <tempofilt+0xf05>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %eax,%eax
movdqa 0x1ae3(%rip),%xmm0
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%r15
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rax,2),%xmm1
movdqu 0x10(%rbx,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,(%r15,%rax,1)
movdqu 0x20(%rbx,%rax,2),%xmm1
movdqu 0x30(%rbx,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,0x10(%r15,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    1530 <tempofilt+0x3b0>
test   $0x1,%cl
je     15a0 <tempofilt+0x420>
movdqu (%rbx,%rax,2),%xmm0
movdqu 0x10(%rbx,%rax,2),%xmm1
movdqa 0x1a72(%rip),%xmm2
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%r15,%rax,1)
cmp    %r14,%rbp
je     15c1 <tempofilt+0x441>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rbp,2),%eax
mov    %al,(%r15,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    15b0 <tempofilt+0x430>
mov    0x50(%rsp),%rcx
lea    -0x1(%rcx),%edx
mov    $0x1,%eax
cmp    $0x3,%ecx
jl     1d76 <tempofilt+0xbf6>
mov    0x50(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0xf8(%rsp)
movslq %r13d,%r8
mov    %edx,0x84(%rsp)
mov    %edx,%eax
mov    %rax,0xf0(%rsp)
mov    %esi,%r10d
mov    %esi,%eax
and    $0xfffffff0,%eax
mov    %rax,0xa0(%rsp)
add    $0xfffffffffffffff0,%rax
mov    %rax,0x98(%rsp)
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %esi,%ebp
and    $0xfffffffe,%ebp
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x88(%rsp)
mov    0x40(%rsp),%r11
lea    (%r15,%r11,2),%rdx
add    $0x1,%rdx
lea    (%r11,%r11,2),%rax
lea    0x1(%r15,%rax,1),%rsi
lea    0x1(%r15,%r11,1),%rax
mov    %rax,0x78(%rsp)
lea    (%r15,%r11,2),%rax
mov    %rax,0xc8(%rsp)
mov    %rbx,%rax
add    $0x2,%rax
mov    %rax,0x110(%rsp)
mov    $0x1,%eax
sub    %r8,%rax
mov    %rax,0xd8(%rsp)
pxor   %xmm2,%xmm2
lea    (%r15,%r11,1),%rax
add    $0x18,%rax
mov    %rax,0xa8(%rsp)
lea    (%r15,%r11,1),%rax
mov    %rax,0xb0(%rsp)
mov    %r8,%rax
mov    %r8,0x48(%rsp)
lea    0x1(%r8),%rax
mov    %rax,0xd0(%rsp)
mov    $0x1,%r9d
mov    %r15,%r14
mov    %r15,0xb8(%rsp)
mov    0x70(%rsp),%r8
mov    %r10,0xe8(%rsp)
mov    %rbp,0xe0(%rsp)
jmp    1732 <tempofilt+0x5b2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    %r11,%rdx
add    %r11,%rsi
add    %r11,0x78(%rsp)
add    %r11,0xb8(%rsp)
add    %r11,0xc8(%rsp)
add    %r11,0xa8(%rsp)
add    %r11,0xb0(%rsp)
cmp    0xf0(%rsp),%r9
mov    0x10(%rsp),%r14
je     1d69 <tempofilt+0xbe9>
cmp    0xf8(%rsp),%r9
mov    %rdx,0x108(%rsp)
mov    %rsi,0x100(%rsp)
mov    %r9,0xc0(%rsp)
jae    17a0 <tempofilt+0x620>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1890 <tempofilt+0x710>
cmp    $0x1,%eax
jne    18a2 <tempofilt+0x722>
xor    %eax,%eax
test   $0x1,%r10b
je     17a0 <tempofilt+0x620>
lea    0x1(%r9),%rdx
imul   %r11,%rdx
add    %r14,%rdx
movzbl (%rdx,%rax,1),%ecx
lea    (%rax,%r11,1),%rsi
cmp    (%rdx,%rsi,1),%cl
je     1796 <tempofilt+0x616>
mov    %rax,%rsi
sub    %r11,%rsi
cmp    (%rdx,%rsi,1),%cl
je     1796 <tempofilt+0x616>
xor    %ecx,%ecx
mov    %cx,(%r8,%rax,2)
nopl   0x0(%rax,%rax,1)
mov    %r9,%rax
imul   %r11,%rax
mov    %r14,%r15
mov    %rax,%r14
add    %rax,%r15
cmpl   $0x0,0x4(%rsp)
jle    19e0 <tempofilt+0x860>
mov    0xb8(%rsp),%rcx
lea    (%rcx,%r11,1),%rax
mov    %rcx,%r11
xor    %ecx,%ecx
jmp    17d9 <tempofilt+0x659>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %rcx,%r10
je     1810 <tempofilt+0x690>
movzbl (%r11,%rcx,1),%edx
test   %edx,%edx
je     17d0 <tempofilt+0x650>
movswl (%r8,%rcx,2),%esi
cmp    %esi,%edx
jne    17d0 <tempofilt+0x650>
mov    -0x8(%rdi,%r9,8),%rbp
movzbl (%rax,%rcx,1),%esi
cmpl   $0x0,0x0(%rbp,%rsi,4)
je     17d0 <tempofilt+0x650>
mov    0x8(%rdi,%r9,8),%rbp
cmpl   $0x0,0x0(%rbp,%rsi,4)
je     17d0 <tempofilt+0x650>
mov    %dl,(%rax,%rcx,1)
jmp    17d0 <tempofilt+0x650>
nopl   0x0(%rax)
mov    0x4(%rsp),%ebp
test   %ebp,%ebp
jle    19e0 <tempofilt+0x860>
xor    %ecx,%ecx
jmp    1838 <tempofilt+0x6b8>
mov    -0x8(%rdi,%r9,8),%rsi
cmpl   $0x0,(%rsi,%rdx,4)
je     1847 <tempofilt+0x6c7>
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r10
je     1870 <tempofilt+0x6f0>
movzbl (%rax,%rcx,1),%edx
test   %rdx,%rdx
je     182f <tempofilt+0x6af>
cmp    (%r11,%rcx,1),%dl
jne    1820 <tempofilt+0x6a0>
mov    0xc8(%rsp),%rsi
cmp    (%rsi,%rcx,1),%dl
je     182f <tempofilt+0x6af>
mov    0x8(%rdi,%r9,8),%rsi
cmpl   $0x0,(%rsi,%rdx,4)
jne    182b <tempofilt+0x6ab>
jmp    182f <tempofilt+0x6af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %ebp,%ebp
mov    0xb0(%rsp),%rsi
jle    19e0 <tempofilt+0x860>
cmp    $0x10,%ebp
jae    1907 <tempofilt+0x787>
xor    %eax,%eax
jmp    19c0 <tempofilt+0x840>
imul   %r11,%r9
mov    %r14,%r15
mov    %r9,%r14
add    %r9,%r15
jmp    19e0 <tempofilt+0x860>
xor    %eax,%eax
jmp    18c3 <tempofilt+0x743>
cs nopw 0x0(%rax,%rax,1)
mov    %cx,0x2(%r8,%rax,2)
add    $0x2,%rax
cmp    %rax,%rbp
je     176b <tempofilt+0x5eb>
movzbl -0x1(%rdx,%rax,1),%ecx
cmp    -0x1(%rsi,%rax,1),%cl
je     18e4 <tempofilt+0x764>
mov    0x78(%rsp),%r9
cmp    -0x1(%r9,%rax,1),%cl
mov    0xc0(%rsp),%r9
je     18e4 <tempofilt+0x764>
xor    %ecx,%ecx
mov    %cx,(%r8,%rax,2)
movzbl (%rdx,%rax,1),%ecx
cmp    (%rsi,%rax,1),%cl
je     18b0 <tempofilt+0x730>
mov    %rbp,%r15
mov    0x78(%rsp),%rbp
cmp    0x0(%rbp,%rax,1),%cl
mov    %r15,%rbp
je     18b0 <tempofilt+0x730>
xor    %ecx,%ecx
jmp    18b0 <tempofilt+0x730>
cmpq   $0x0,0x98(%rsp)
mov    0xa8(%rsp),%rdx
je     1d54 <tempofilt+0xbd4>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movq   -0x18(%rdx,%rax,1),%xmm0
movq   -0x10(%rdx,%rax,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rax,2)
movdqu %xmm1,0x10(%rbx,%rax,2)
movq   -0x8(%rdx,%rax,1),%xmm0
movq   (%rdx,%rax,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,0x20(%rbx,%rax,2)
movdqu %xmm1,0x30(%rbx,%rax,2)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    1930 <tempofilt+0x7b0>
testb  $0x1,0x90(%rsp)
01
je     19a2 <tempofilt+0x822>
movq   (%r15,%rax,1),%xmm0
movq   0x8(%r15,%rax,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rax,2)
movdqu %xmm1,0x10(%rbx,%rax,2)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
je     19e0 <tempofilt+0x860>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsi,%rax,1),%ecx
mov    %cx,(%rbx,%rax,2)
add    $0x1,%rax
cmp    %rax,%r10
jne    19c0 <tempofilt+0x840>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r12d,%r12d
jle    1b90 <tempofilt+0xa10>
mov    0xd0(%rsp),%rax
lea    (%r15,%rax,1),%rdi
mov    0xd8(%rsp),%rax
lea    (%r15,%rax,1),%r9
xor    %r10d,%r10d
xor    %eax,%eax
jmp    1a20 <tempofilt+0x8a0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
mov    %eax,%esi
mov    %esi,%eax
cmp    %r12d,%esi
je     1b90 <tempofilt+0xa10>
test   %r13d,%r13d
jle    1a10 <tempofilt+0x890>
lea    0x1(%rax),%esi
movslq %r10d,%r10
cmpb   $0x0,(%r15,%r10,1)
je     1aa0 <tempofilt+0x920>
test   %eax,%eax
je     1a45 <tempofilt+0x8c5>
mov    %r10,%rcx
sub    0x48(%rsp),%rcx
cmpb   $0x0,(%r15,%rcx,1)
je     1a61 <tempofilt+0x8e1>
cmp    $0x2,%r13d
jb     1a80 <tempofilt+0x900>
cmpb   $0x0,0x1(%r10,%r15,1)
jne    1a80 <tempofilt+0x900>
mov    0x8(%rsp),%rcx
movw   $0x0,(%rcx,%r10,2)
jmp    1a80 <tempofilt+0x900>
mov    0x8(%rsp),%rcx
movw   $0x0,(%rcx,%r10,2)
cmp    $0x2,%r13d
jae    1a4b <tempofilt+0x8cb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r12d,%esi
jge    1aa0 <tempofilt+0x920>
mov    0x48(%rsp),%rcx
add    %r10,%rcx
cmpb   $0x0,(%r15,%rcx,1)
je     1aaf <tempofilt+0x92f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x1,%r13d
jne    1ad0 <tempofilt+0x950>
add    $0x1,%r10
jmp    1a15 <tempofilt+0x895>
mov    0x8(%rsp),%rcx
movw   $0x0,(%rcx,%r10,2)
cmp    $0x1,%r13d
je     1aa6 <tempofilt+0x926>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%r10,1),%r11
lea    (%r15,%r10,1),%rbx
mov    0x110(%rsp),%rcx
lea    (%rcx,%r10,2),%rbp
lea    (%r9,%r10,1),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
jmp    1b0c <tempofilt+0x98c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%ecx
add    $0x1,%r8
cmp    %r13d,%ecx
je     1b80 <tempofilt+0xa00>
cmpb   $0x0,0x1(%rbx,%r8,1)
je     1b00 <tempofilt+0x980>
test   %eax,%eax
je     1b1f <tempofilt+0x99f>
cmpb   $0x0,(%rdx,%r8,1)
je     1b54 <tempofilt+0x9d4>
cmpb   $0x0,(%rbx,%r8,1)
jne    1b2e <tempofilt+0x9ae>
movw   $0x0,0x0(%rbp,%r8,2)
add    $0x1,%ecx
cmp    %r13d,%ecx
jge    1b3e <tempofilt+0x9be>
cmpb   $0x0,0x2(%rbx,%r8,1)
je     1b65 <tempofilt+0x9e5>
cmp    %r12d,%esi
jge    1b03 <tempofilt+0x983>
cmpb   $0x0,(%r11,%r8,1)
jne    1b03 <tempofilt+0x983>
movw   $0x0,0x0(%rbp,%r8,2)
jmp    1b03 <tempofilt+0x983>
movw   $0x0,0x0(%rbp,%r8,2)
cmpb   $0x0,(%rbx,%r8,1)
jne    1b2e <tempofilt+0x9ae>
jmp    1b26 <tempofilt+0x9a6>
movw   $0x0,0x0(%rbp,%r8,2)
cmp    %r12d,%esi
jge    1b03 <tempofilt+0x983>
jmp    1b43 <tempofilt+0x9c3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r8,%r10
add    $0x1,%r10
jmp    1a15 <tempofilt+0x895>
nopl   0x0(%rax)
add    0x68(%rsp),%r14
mov    0x58(%rsp),%rax
mov    0x4(%rax),%r9d
mov    0x60(%rsp),%rax
mov    0x4(%rax),%r10d
mov    %r14,%rdi
mov    0x24(%rsp),%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    0x18(%rsp),%r8
xor    %eax,%eax
push   $0x1
mov    0x38(%rsp),%r14
push   %r14
mov    0x18(%rsp),%rbx
push   %rbx
push   %r10
call   1030 <getJ@plt>
add    $0x20,%rsp
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r14,%r8
xor    %eax,%eax
call   1090 <removehole@plt>
mov    0x38(%rsp),%rbp
mov    0x0(%rbp),%rax
movl   $0x0,0x4(%rax)
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
mov    $0x1,%edx
mov    %r12d,%ecx
mov    %r13d,%r8d
mov    %r14,%r9
xor    %eax,%eax
push   %rbp
push   $0x1
call   10a0 <flood@plt>
add    $0x10,%rsp
cmpl   $0x0,0x4(%rsp)
mov    0x70(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%r11
mov    0xe8(%rsp),%r10
mov    0xe0(%rsp),%rbp
mov    0x108(%rsp),%rdx
mov    0x100(%rsp),%rsi
pxor   %xmm2,%xmm2
movdqa 0x139f(%rip),%xmm3
mov    0xc0(%rsp),%r9
jle    16f0 <tempofilt+0x570>
cmpl   $0x10,0x4(%rsp)
jae    1c80 <tempofilt+0xb00>
xor    %eax,%eax
jmp    1d30 <tempofilt+0xbb0>
nopl   (%rax)
cmpq   $0x0,0x98(%rsp)
je     1d46 <tempofilt+0xbc6>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movdqu (%rbx,%rax,2),%xmm0
movdqu 0x10(%rbx,%rax,2),%xmm1
pand   %xmm3,%xmm0
pand   %xmm3,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%r15,%rax,1)
movdqu 0x20(%rbx,%rax,2),%xmm0
movdqu 0x30(%rbx,%rax,2),%xmm1
pand   %xmm3,%xmm0
pand   %xmm3,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,0x10(%r15,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    1ca0 <tempofilt+0xb20>
testb  $0x1,0x90(%rsp)
01
je     1d0d <tempofilt+0xb8d>
movdqu (%rbx,%rax,2),%xmm0
movdqu 0x10(%rbx,%rax,2),%xmm1
pand   %xmm3,%xmm0
pand   %xmm3,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%r15,%rax,1)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
je     16f0 <tempofilt+0x570>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,2),%ecx
mov    %cl,(%r15,%rax,1)
add    $0x1,%rax
cmp    %rax,%r10
jne    1d30 <tempofilt+0xbb0>
jmp    16f0 <tempofilt+0x570>
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
jne    1cf0 <tempofilt+0xb70>
jmp    1d0d <tempofilt+0xb8d>
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
jne    1982 <tempofilt+0x802>
jmp    19a2 <tempofilt+0x822>
mov    0x84(%rsp),%edx
mov    %edx,%eax
mov    0x4(%rsp),%esi
test   %esi,%esi
jle    2021 <tempofilt+0xea1>
imul   %esi,%edx
movslq %edx,%r9
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,1),%r14
mov    %esi,%r15d
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x0,(%r14,%rcx,1)
je     1db5 <tempofilt+0xc35>
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1da0 <tempofilt+0xc20>
jmp    2021 <tempofilt+0xea1>
cmp    $0x10,%esi
mov    %r9,0x48(%rsp)
jae    1dc6 <tempofilt+0xc46>
xor    %ecx,%ecx
jmp    1e80 <tempofilt+0xd00>
mov    %r15d,%ecx
and    $0xfffffff0,%ecx
lea    -0x10(%rcx),%rdx
mov    %rdx,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     209f <tempofilt+0xf1f>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x10(%rsp),%rdx
lea    (%r9,%rdx,1),%rbp
add    $0x18,%rbp
xor    %edx,%edx
pxor   %xmm0,%xmm0
xchg   %ax,%ax
movq   -0x18(%rbp,%rdx,1),%xmm1
movq   -0x10(%rbp,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdx,2)
movdqu %xmm2,0x10(%rbx,%rdx,2)
movq   -0x8(%rbp,%rdx,1),%xmm1
movq   0x0(%rbp,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%rbx,%rdx,2)
movdqu %xmm2,0x30(%rbx,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1e00 <tempofilt+0xc80>
test   $0x1,%r8b
je     1e73 <tempofilt+0xcf3>
movq   (%r14,%rdx,1),%xmm0
movq   0x8(%r14,%rdx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rdx,2)
movdqu %xmm1,0x10(%rbx,%rdx,2)
cmp    %r15,%rcx
je     1e92 <tempofilt+0xd12>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%edx
mov    %dx,(%rbx,%rcx,2)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1e80 <tempofilt+0xd00>
imul   %esi,%eax
cltq
mov    0x68(%rsp),%rdi
add    %rax,%rdi
mov    %rbx,%r11
mov    0x58(%rsp),%rax
mov    0x4(%rax),%r9d
mov    0x60(%rsp),%rax
mov    0x4(%rax),%r10d
xor    %ebp,%ebp
mov    0x24(%rsp),%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    0x18(%rsp),%r8
xor    %eax,%eax
push   $0x1
mov    0x38(%rsp),%rbx
push   %rbx
push   %r11
push   %r10
call   1030 <getJ@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %rbx,%r8
xor    %eax,%eax
call   1090 <removehole@plt>
mov    0x38(%rsp),%rbx
mov    (%rbx),%rax
movl   $0x0,0x4(%rax)
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    $0x1,%edx
mov    %r12d,%ecx
mov    %r13d,%r8d
mov    0x30(%rsp),%r9
xor    %eax,%eax
push   %rbx
push   $0x1
call   10a0 <flood@plt>
add    $0x10,%rsp
cmpl   $0x10,0x4(%rsp)
jae    1f43 <tempofilt+0xdc3>
mov    0x8(%rsp),%rbx
mov    0x28(%rsp),%rdi
jmp    2010 <tempofilt+0xe90>
mov    %r15d,%ebp
and    $0xfffffff0,%ebp
lea    -0x10(%rbp),%rax
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
test   %rax,%rax
mov    0x28(%rsp),%rdi
je     20b0 <tempofilt+0xf30>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x10(%rsp),%rax
mov    0x48(%rsp),%rsi
add    %rax,%rsi
add    $0x18,%rsi
xor    %eax,%eax
movdqa 0x1078(%rip),%xmm0
mov    0x8(%rsp),%rbx
nopl   (%rax)
movdqu (%rbx,%rax,2),%xmm1
movdqu 0x10(%rbx,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,-0x18(%rsi,%rax,1)
movdqu 0x20(%rbx,%rax,2),%xmm1
movdqu 0x30(%rbx,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,-0x8(%rsi,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    1f90 <tempofilt+0xe10>
test   $0x1,%cl
je     1fff <tempofilt+0xe7f>
movdqu (%rbx,%rax,2),%xmm0
movdqu 0x10(%rbx,%rax,2),%xmm1
movdqa 0x1013(%rip),%xmm2
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%r14,%rax,1)
cmp    %r15,%rbp
je     2021 <tempofilt+0xea1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rbp,2),%eax
mov    %al,(%r14,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    2010 <tempofilt+0xe90>
mov    0x50(%rsp),%rsi
xor    %eax,%eax
call   1080 <free_imatrix@plt>
mov    0x30(%rsp),%rdi
call   1040 <free@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    0x70(%rsp),%rdi
call   1040 <free@plt>
mov    0x18(%rsp),%rdi
call   1040 <free@plt>
mov    0x38(%rsp),%rdi
mov    $0x1,%esi
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <free_imatrix@plt>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1401 <tempofilt+0x281>
jmp    1425 <tempofilt+0x2a5>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%r15
test   $0x1,%cl
jne    157b <tempofilt+0x3fb>
jmp    15a0 <tempofilt+0x420>
xor    %edx,%edx
test   $0x1,%r8b
jne    1e4f <tempofilt+0xccf>
jmp    1e73 <tempofilt+0xcf3>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
test   $0x1,%cl
jne    1fda <tempofilt+0xe5a>
jmp    1fff <tempofilt+0xe7f>

LLVM IR (-O0):
define void @tempofilt(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i8* %5, i32* %6, i32* %7) {
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8*
%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 i8*
%26 = alloca i8*
%27 = alloca i16*
%28 = alloca i16*
%29 = alloca float*
store i8* %0, i8** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i8* %5, i8** %14
store i32* %6, i32** %15
store i32* %7, i32** %16
%30 = load i32, i32* %11
%31 = load i32, i32* %12
%32 = mul nsw i32 %30, %31
store i32 %32, i32* %18
%33 = load i32, i32* %18
%34 = sext i32 %33 to i64
%35 = call i8* @calloc(i64 %34, i64 2)
%36 = bitcast i8* %35 to i16*
store i16* %36, i16** %27
%37 = load i32, i32* %18
%38 = sext i32 %37 to i64
%39 = call i8* @calloc(i64 %38, i64 2)
%40 = bitcast i8* %39 to i16*
store i16* %40, i16** %28
%41 = load i32, i32* %18
%42 = sext i32 %41 to i64
%43 = call i8* @calloc(i64 %42, i64 1)
store i8* %43, i8** %25
store i32 0, i32* %17
br label %44
44: ; preds = %53, %8
%45 = load i32, i32* %17
%46 = load i32, i32* %18
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %56
48: ; preds = %44
%49 = load i8*, i8** %25
%50 = load i32, i32* %17
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
store i8 1, i8* %52
br label %53
53: ; preds = %48
%54 = load i32, i32* %17
%55 = add nsw i32 %54, 1
store i32 %55, i32* %17
br label %44
56: ; preds = %44
%57 = load i32, i32* %18
%58 = sext i32 %57 to i64
%59 = call i8* @calloc(i64 %58, i64 4)
%60 = bitcast i8* %59 to float*
store float* %60, float** %29
%61 = call i32 (i32, i32, ...) bitcast (i32 (...)* @imatrix to i32 (i32, i32, ...)*)(i32 1, i32 2)
%62 = sext i32 %61 to i64
%63 = inttoptr i64 %62 to i32**
store i32** %63, i32*** %20
%64 = load i32, i32* %10
%65 = call i32 (i32, i32, ...) bitcast (i32 (...)* @imatrix to i32 (i32, i32, ...)*)(i32 %64, i32 256)
%66 = sext i32 %65 to i64
%67 = inttoptr i64 %66 to i32**
store i32** %67, i32*** %21
%68 = load i8*, i8** %9
store i8* %68, i8** %26
store i32 0, i32* %19
br label %69
69: ; preds = %99, %56
%70 = load i32, i32* %19
%71 = load i32, i32* %10
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %102
73: ; preds = %69
store i32 0, i32* %17
br label %74
74: ; preds = %91, %73
%75 = load i32, i32* %17
%76 = load i32, i32* %18
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %94
78: ; preds = %74
%79 = load i32**, i32*** %21
%80 = load i32, i32* %19
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32*, i32** %79, i64 %81
%83 = load i32*, i32** %82
%84 = load i8*, i8** %26
%85 = load i32, i32* %17
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
%88 = load i8, i8* %87
%89 = zext i8 %88 to i64
%90 = getelementptr inbounds i32, i32* %83, i64 %89
store i32 1, i32* %90
br label %91
91: ; preds = %78
%92 = load i32, i32* %17
%93 = add nsw i32 %92, 1
store i32 %93, i32* %17
br label %74
94: ; preds = %74
%95 = load i32, i32* %18
%96 = load i8*, i8** %26
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds i8, i8* %96, i64 %97
store i8* %98, i8** %26
br label %99
99: ; preds = %94
%100 = load i32, i32* %19
%101 = add nsw i32 %100, 1
store i32 %101, i32* %19
br label %69
102: ; preds = %69
%103 = load i8*, i8** %9
store i8* %103, i8** %26
store i32 0, i32* %17
br label %104
104: ; preds = %118, %102
%105 = load i32, i32* %17
%106 = load i32, i32* %18
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %121
108: ; preds = %104
%109 = load i8*, i8** %26
%110 = load i32, i32* %17
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %109, i64 %111
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = icmp eq i32 %114, 0
br i1 %115, label %116, label %117
116: ; preds = %108
br label %121
117: ; preds = %108
br label %118
118: ; preds = %117
%119 = load i32, i32* %17
%120 = add nsw i32 %119, 1
store i32 %120, i32* %17
br label %104
121: ; preds = %116, %104
%122 = load i32, i32* %17
%123 = load i32, i32* %18
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %194
125: ; preds = %121
store i32 0, i32* %17
br label %126
126: ; preds = %141, %125
%127 = load i32, i32* %17
%128 = load i32, i32* %18
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %144
130: ; preds = %126
%131 = load i8*, i8** %26
%132 = load i32, i32* %17
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = load i8, i8* %134
%136 = zext i8 %135 to i16
%137 = load i16*, i16** %27
%138 = load i32, i32* %17
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i16, i16* %137, i64 %139
store i16 %136, i16* %140
br label %141
141: ; preds = %130
%142 = load i32, i32* %17
%143 = add nsw i32 %142, 1
store i32 %143, i32* %17
br label %126
144: ; preds = %126
%145 = load i8*, i8** %14
%146 = load i32, i32* %13
%147 = load i32, i32* %11
%148 = load i32, i32* %12
%149 = load float*, float** %29
%150 = load i32*, i32** %15
%151 = getelementptr inbounds i32, i32* %150, i64 1
%152 = load i32, i32* %151
%153 = load i32*, i32** %16
%154 = getelementptr inbounds i32, i32* %153, i64 1
%155 = load i32, i32* %154
%156 = load i16*, i16** %27
%157 = load i8*, i8** %25
%158 = call i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...) bitcast (i32 (...)* @getJ to i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...)*)(i8* %145, i32 %146, i32 %147, i32 %148, float* %149, i32 %152, i32 %155, i16* %156, i8* %157, i32 1)
%159 = load i16*, i16** %27
%160 = load i32, i32* %11
%161 = load i32, i32* %12
%162 = load i8*, i8** %25
%163 = call i32 (i16*, i32, i32, i32, i8*, ...) bitcast (i32 (...)* @removehole to i32 (i16*, i32, i32, i32, i8*, ...)*)(i16* %159, i32 1, i32 %160, i32 %161, i8* %162)
%164 = load i32**, i32*** %20
%165 = getelementptr inbounds i32*, i32** %164, i64 0
%166 = load i32*, i32** %165
%167 = getelementptr inbounds i32, i32* %166, i64 1
store i32 0, i32* %167
%168 = load i16*, i16** %27
%169 = load float*, float** %29
%170 = load i32, i32* %11
%171 = load i32, i32* %12
%172 = load i8*, i8** %25
%173 = load i32**, i32*** %20
%174 = call i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...) bitcast (i32 (...)* @flood to i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...)*)(i16* %168, float* %169, i32 1, i32 %170, i32 %171, i8* %172, i32 1, i32** %173)
store i32 0, i32* %17
br label %175
175: ; preds = %190, %144
%176 = load i32, i32* %17
%177 = load i32, i32* %18
%178 = icmp slt i32 %176, %177
br i1 %178, label %179, label %193
179: ; preds = %175
%180 = load i16*, i16** %27
%181 = load i32, i32* %17
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i16, i16* %180, i64 %182
%184 = load i16, i16* %183
%185 = trunc i16 %184 to i8
%186 = load i8*, i8** %26
%187 = load i32, i32* %17
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %186, i64 %188
store i8 %185, i8* %189
br label %190
190: ; preds = %179
%191 = load i32, i32* %17
%192 = add nsw i32 %191, 1
store i32 %192, i32* %17
br label %175
193: ; preds = %175
br label %194
194: ; preds = %193, %121
store i32 1, i32* %19
br label %195
195: ; preds = %632, %194
%196 = load i32, i32* %19
%197 = load i32, i32* %10
%198 = sub nsw i32 %197, 1
%199 = icmp slt i32 %196, %198
br i1 %199, label %200, label %635
200: ; preds = %195
%201 = load i32, i32* %19
%202 = load i32, i32* %10
%203 = sub nsw i32 %202, 2
%204 = icmp slt i32 %201, %203
br i1 %204, label %205, label %270
205: ; preds = %200
%206 = load i8*, i8** %9
%207 = load i32, i32* %19
%208 = add nsw i32 %207, 1
%209 = load i32, i32* %18
%210 = mul nsw i32 %208, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %206, i64 %211
store i8* %212, i8** %26
store i32 0, i32* %17
br label %213
213: ; preds = %266, %205
%214 = load i32, i32* %17
%215 = load i32, i32* %18
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %269
217: ; preds = %213
%218 = load i8*, i8** %26
%219 = load i32, i32* %17
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i8, i8* %218, i64 %220
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = load i8*, i8** %26
%225 = load i32, i32* %17
%226 = load i32, i32* %18
%227 = add nsw i32 %225, %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i8, i8* %224, i64 %228
%230 = load i8, i8* %229
%231 = zext i8 %230 to i32
%232 = icmp ne i32 %223, %231
br i1 %232, label %233, label %254
233: ; preds = %217
%234 = load i8*, i8** %26
%235 = load i32, i32* %17
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i8, i8* %234, i64 %236
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = load i8*, i8** %26
%241 = load i32, i32* %17
%242 = load i32, i32* %18
%243 = sub nsw i32 %241, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %240, i64 %244
%246 = load i8, i8* %245
%247 = zext i8 %246 to i32
%248 = icmp ne i32 %239, %247
br i1 %248, label %249, label %254
249: ; preds = %233
%250 = load i16*, i16** %28
%251 = load i32, i32* %17
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i16, i16* %250, i64 %252
store i16 0, i16* %253
br label %265
254: ; preds = %233, %217
%255 = load i8*, i8** %26
%256 = load i32, i32* %17
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i8, i8* %255, i64 %257
%259 = load i8, i8* %258
%260 = zext i8 %259 to i16
%261 = load i16*, i16** %28
%262 = load i32, i32* %17
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i16, i16* %261, i64 %263
store i16 %260, i16* %264
br label %265
265: ; preds = %254, %249
br label %266
266: ; preds = %265
%267 = load i32, i32* %17
%268 = add nsw i32 %267, 1
store i32 %268, i32* %17
br label %213
269: ; preds = %213
br label %270
270: ; preds = %269, %200
%271 = load i8*, i8** %9
%272 = load i32, i32* %19
%273 = load i32, i32* %18
%274 = mul nsw i32 %272, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i8, i8* %271, i64 %275
store i8* %276, i8** %26
store i32 0, i32* %17
br label %277
277: ; preds = %353, %270
%278 = load i32, i32* %17
%279 = load i32, i32* %18
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %356
281: ; preds = %277
%282 = load i8*, i8** %26
%283 = load i32, i32* %17
%284 = load i32, i32* %18
%285 = sub nsw i32 %283, %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8, i8* %282, i64 %286
%288 = load i8, i8* %287
%289 = zext i8 %288 to i32
%290 = load i16*, i16** %28
%291 = load i32, i32* %17
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i16, i16* %290, i64 %292
%294 = load i16, i16* %293
%295 = sext i16 %294 to i32
%296 = icmp eq i32 %289, %295
br i1 %296, label %297, label %352
297: ; preds = %281
%298 = load i8*, i8** %26
%299 = load i32, i32* %17
%300 = load i32, i32* %18
%301 = sub nsw i32 %299, %300
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i8, i8* %298, i64 %302
%304 = load i8, i8* %303
%305 = zext i8 %304 to i32
%306 = icmp sgt i32 %305, 0
br i1 %306, label %307, label %352
307: ; preds = %297
%308 = load i32**, i32*** %21
%309 = load i32, i32* %19
%310 = sub nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32*, i32** %308, i64 %311
%313 = load i32*, i32** %312
%314 = load i8*, i8** %26
%315 = load i32, i32* %17
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i8, i8* %314, i64 %316
%318 = load i8, i8* %317
%319 = zext i8 %318 to i64
%320 = getelementptr inbounds i32, i32* %313, i64 %319
%321 = load i32, i32* %320
%322 = icmp ne i32 %321, 0
br i1 %322, label %323, label %351
323: ; preds = %307
%324 = load i32**, i32*** %21
%325 = load i32, i32* %19
%326 = add nsw i32 %325, 1
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i32*, i32** %324, i64 %327
%329 = load i32*, i32** %328
%330 = load i8*, i8** %26
%331 = load i32, i32* %17
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i8, i8* %330, i64 %332
%334 = load i8, i8* %333
%335 = zext i8 %334 to i64
%336 = getelementptr inbounds i32, i32* %329, i64 %335
%337 = load i32, i32* %336
%338 = icmp ne i32 %337, 0
br i1 %338, label %339, label %351
339: ; preds = %323
%340 = load i8*, i8** %26
%341 = load i32, i32* %17
%342 = load i32, i32* %18
%343 = sub nsw i32 %341, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds i8, i8* %340, i64 %344
%346 = load i8, i8* %345
%347 = load i8*, i8** %26
%348 = load i32, i32* %17
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i8, i8* %347, i64 %349
store i8 %346, i8* %350
br label %351
351: ; preds = %339, %323, %307
br label %352
352: ; preds = %351, %297, %281
br label %353
353: ; preds = %352
%354 = load i32, i32* %17
%355 = add nsw i32 %354, 1
store i32 %355, i32* %17
br label %277
356: ; preds = %277
store i32 0, i32* %17
br label %357
357: ; preds = %446, %356
%358 = load i32, i32* %17
%359 = load i32, i32* %18
%360 = icmp slt i32 %358, %359
br i1 %360, label %361, label %449
361: ; preds = %357
%362 = load i8*, i8** %26
%363 = load i32, i32* %17
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i8, i8* %362, i64 %364
%366 = load i8, i8* %365
%367 = zext i8 %366 to i32
%368 = icmp sgt i32 %367, 0
br i1 %368, label %369, label %445
369: ; preds = %361
%370 = load i8*, i8** %26
%371 = load i32, i32* %17
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds i8, i8* %370, i64 %372
%374 = load i8, i8* %373
%375 = zext i8 %374 to i32
%376 = load i8*, i8** %26
%377 = load i32, i32* %17
%378 = load i32, i32* %18
%379 = sub nsw i32 %377, %378
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds i8, i8* %376, i64 %380
%382 = load i8, i8* %381
%383 = zext i8 %382 to i32
%384 = icmp ne i32 %375, %383
br i1 %384, label %385, label %406
385: ; preds = %369
%386 = load i32**, i32*** %21
%387 = load i32, i32* %19
%388 = sub nsw i32 %387, 1
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i32*, i32** %386, i64 %389
%391 = load i32*, i32** %390
%392 = load i8*, i8** %26
%393 = load i32, i32* %17
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds i8, i8* %392, i64 %394
%396 = load i8, i8* %395
%397 = zext i8 %396 to i64
%398 = getelementptr inbounds i32, i32* %391, i64 %397
%399 = load i32, i32* %398
%400 = icmp ne i32 %399, 0
br i1 %400, label %401, label %406
401: ; preds = %385
%402 = load i8*, i8** %26
%403 = load i32, i32* %17
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds i8, i8* %402, i64 %404
store i8 0, i8* %405
br label %444
406: ; preds = %385, %369
%407 = load i8*, i8** %26
%408 = load i32, i32* %17
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i8, i8* %407, i64 %409
%411 = load i8, i8* %410
%412 = zext i8 %411 to i32
%413 = load i8*, i8** %26
%414 = load i32, i32* %17
%415 = load i32, i32* %18
%416 = add nsw i32 %414, %415
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8, i8* %413, i64 %417
%419 = load i8, i8* %418
%420 = zext i8 %419 to i32
%421 = icmp ne i32 %412, %420
br i1 %421, label %422, label %443
422: ; preds = %406
%423 = load i32**, i32*** %21
%424 = load i32, i32* %19
%425 = add nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i32*, i32** %423, i64 %426
%428 = load i32*, i32** %427
%429 = load i8*, i8** %26
%430 = load i32, i32* %17
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i8, i8* %429, i64 %431
%433 = load i8, i8* %432
%434 = zext i8 %433 to i64
%435 = getelementptr inbounds i32, i32* %428, i64 %434
%436 = load i32, i32* %435
%437 = icmp ne i32 %436, 0
br i1 %437, label %438, label %443
438: ; preds = %422
%439 = load i8*, i8** %26
%440 = load i32, i32* %17
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds i8, i8* %439, i64 %441
store i8 0, i8* %442
br label %443
443: ; preds = %438, %422, %406
br label %444
444: ; preds = %443, %401
br label %445
445: ; preds = %444, %361
br label %446
446: ; preds = %445
%447 = load i32, i32* %17
%448 = add nsw i32 %447, 1
store i32 %448, i32* %17
br label %357
449: ; preds = %357
store i32 0, i32* %17
br label %450
450: ; preds = %465, %449
%451 = load i32, i32* %17
%452 = load i32, i32* %18
%453 = icmp slt i32 %451, %452
br i1 %453, label %454, label %468
454: ; preds = %450
%455 = load i8*, i8** %26
%456 = load i32, i32* %17
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds i8, i8* %455, i64 %457
%459 = load i8, i8* %458
%460 = zext i8 %459 to i16
%461 = load i16*, i16** %27
%462 = load i32, i32* %17
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds i16, i16* %461, i64 %463
store i16 %460, i16* %464
br label %465
465: ; preds = %454
%466 = load i32, i32* %17
%467 = add nsw i32 %466, 1
store i32 %467, i32* %17
br label %450
468: ; preds = %450
store i32 0, i32* %17
store i32 0, i32* %22
br label %469
469: ; preds = %574, %468
%470 = load i32, i32* %22
%471 = load i32, i32* %11
%472 = icmp slt i32 %470, %471
br i1 %472, label %473, label %577
473: ; preds = %469
store i32 0, i32* %23
br label %474
474: ; preds = %570, %473
%475 = load i32, i32* %23
%476 = load i32, i32* %12
%477 = icmp slt i32 %475, %476
br i1 %477, label %478, label %573
478: ; preds = %474
%479 = load i8*, i8** %26
%480 = load i32, i32* %17
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i8, i8* %479, i64 %481
%483 = load i8, i8* %482
%484 = zext i8 %483 to i32
%485 = icmp sgt i32 %484, 0
br i1 %485, label %486, label %567
486: ; preds = %478
%487 = load i32, i32* %22
%488 = sub nsw i32 %487, 1
%489 = icmp sge i32 %488, 0
br i1 %489, label %490, label %506
490: ; preds = %486
%491 = load i8*, i8** %26
%492 = load i32, i32* %17
%493 = load i32, i32* %12
%494 = sub nsw i32 %492, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds i8, i8* %491, i64 %495
%497 = load i8, i8* %496
%498 = zext i8 %497 to i32
%499 = icmp eq i32 %498, 0
br i1 %499, label %500, label %505
500: ; preds = %490
%501 = load i16*, i16** %27
%502 = load i32, i32* %17
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i16, i16* %501, i64 %503
store i16 0, i16* %504
br label %505
505: ; preds = %500, %490
br label %506
506: ; preds = %505, %486
%507 = load i32, i32* %23
%508 = sub nsw i32 %507, 1
%509 = icmp sge i32 %508, 0
br i1 %509, label %510, label %525
510: ; preds = %506
%511 = load i8*, i8** %26
%512 = load i32, i32* %17
%513 = sub nsw i32 %512, 1
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i8, i8* %511, i64 %514
%516 = load i8, i8* %515
%517 = zext i8 %516 to i32
%518 = icmp eq i32 %517, 0
br i1 %518, label %519, label %524
519: ; preds = %510
%520 = load i16*, i16** %27
%521 = load i32, i32* %17
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i16, i16* %520, i64 %522
store i16 0, i16* %523
br label %524
524: ; preds = %519, %510
br label %525
525: ; preds = %524, %506
%526 = load i32, i32* %23
%527 = add nsw i32 %526, 1
%528 = load i32, i32* %12
%529 = icmp slt i32 %527, %528
br i1 %529, label %530, label %545
530: ; preds = %525
%531 = load i8*, i8** %26
%532 = load i32, i32* %17
%533 = add nsw i32 %532, 1
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds i8, i8* %531, i64 %534
%536 = load i8, i8* %535
%537 = zext i8 %536 to i32
%538 = icmp eq i32 %537, 0
br i1 %538, label %539, label %544
539: ; preds = %530
%540 = load i16*, i16** %27
%541 = load i32, i32* %17
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i16, i16* %540, i64 %542
store i16 0, i16* %543
br label %544
544: ; preds = %539, %530
br label %545
545: ; preds = %544, %525
%546 = load i32, i32* %22
%547 = add nsw i32 %546, 1
%548 = load i32, i32* %11
%549 = icmp slt i32 %547, %548
br i1 %549, label %550, label %566
550: ; preds = %545
%551 = load i8*, i8** %26
%552 = load i32, i32* %17
%553 = load i32, i32* %12
%554 = add nsw i32 %552, %553
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %551, i64 %555
%557 = load i8, i8* %556
%558 = zext i8 %557 to i32
%559 = icmp eq i32 %558, 0
br i1 %559, label %560, label %565
560: ; preds = %550
%561 = load i16*, i16** %27
%562 = load i32, i32* %17
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i16, i16* %561, i64 %563
store i16 0, i16* %564
br label %565
565: ; preds = %560, %550
br label %566
566: ; preds = %565, %545
br label %567
567: ; preds = %566, %478
%568 = load i32, i32* %17
%569 = add nsw i32 %568, 1
store i32 %569, i32* %17
br label %570
570: ; preds = %567
%571 = load i32, i32* %23
%572 = add nsw i32 %571, 1
store i32 %572, i32* %23
br label %474
573: ; preds = %474
br label %574
574: ; preds = %573
%575 = load i32, i32* %22
%576 = add nsw i32 %575, 1
store i32 %576, i32* %22
br label %469
577: ; preds = %469
%578 = load i8*, i8** %14
%579 = load i32, i32* %19
%580 = load i32, i32* %18
%581 = mul nsw i32 %579, %580
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds i8, i8* %578, i64 %582
%584 = load i32, i32* %13
%585 = load i32, i32* %11
%586 = load i32, i32* %12
%587 = load float*, float** %29
%588 = load i32*, i32** %15
%589 = getelementptr inbounds i32, i32* %588, i64 1
%590 = load i32, i32* %589
%591 = load i32*, i32** %16
%592 = getelementptr inbounds i32, i32* %591, i64 1
%593 = load i32, i32* %592
%594 = load i16*, i16** %27
%595 = load i8*, i8** %25
%596 = call i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...) bitcast (i32 (...)* @getJ to i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...)*)(i8* %583, i32 %584, i32 %585, i32 %586, float* %587, i32 %590, i32 %593, i16* %594, i8* %595, i32 1)
%597 = load i16*, i16** %27
%598 = load i32, i32* %11
%599 = load i32, i32* %12
%600 = load i8*, i8** %25
%601 = call i32 (i16*, i32, i32, i32, i8*, ...) bitcast (i32 (...)* @removehole to i32 (i16*, i32, i32, i32, i8*, ...)*)(i16* %597, i32 1, i32 %598, i32 %599, i8* %600)
%602 = load i32**, i32*** %20
%603 = getelementptr inbounds i32*, i32** %602, i64 0
%604 = load i32*, i32** %603
%605 = getelementptr inbounds i32, i32* %604, i64 1
store i32 0, i32* %605
%606 = load i16*, i16** %27
%607 = load float*, float** %29
%608 = load i32, i32* %11
%609 = load i32, i32* %12
%610 = load i8*, i8** %25
%611 = load i32**, i32*** %20
%612 = call i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...) bitcast (i32 (...)* @flood to i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...)*)(i16* %606, float* %607, i32 1, i32 %608, i32 %609, i8* %610, i32 1, i32** %611)
store i32 0, i32* %17
br label %613
613: ; preds = %628, %577
%614 = load i32, i32* %17
%615 = load i32, i32* %18
%616 = icmp slt i32 %614, %615
br i1 %616, label %617, label %631
617: ; preds = %613
%618 = load i16*, i16** %27
%619 = load i32, i32* %17
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds i16, i16* %618, i64 %620
%622 = load i16, i16* %621
%623 = trunc i16 %622 to i8
%624 = load i8*, i8** %26
%625 = load i32, i32* %17
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds i8, i8* %624, i64 %626
store i8 %623, i8* %627
br label %628
628: ; preds = %617
%629 = load i32, i32* %17
%630 = add nsw i32 %629, 1
store i32 %630, i32* %17
br label %613
631: ; preds = %613
br label %632
632: ; preds = %631
%633 = load i32, i32* %19
%634 = add nsw i32 %633, 1
store i32 %634, i32* %19
br label %195
635: ; preds = %195
%636 = load i8*, i8** %9
%637 = load i32, i32* %10
%638 = sub nsw i32 %637, 1
%639 = load i32, i32* %18
%640 = mul nsw i32 %638, %639
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds i8, i8* %636, i64 %641
store i8* %642, i8** %26
store i32 0, i32* %17
br label %643
643: ; preds = %657, %635
%644 = load i32, i32* %17
%645 = load i32, i32* %18
%646 = icmp slt i32 %644, %645
br i1 %646, label %647, label %660
647: ; preds = %643
%648 = load i8*, i8** %26
%649 = load i32, i32* %17
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds i8, i8* %648, i64 %650
%652 = load i8, i8* %651
%653 = zext i8 %652 to i32
%654 = icmp eq i32 %653, 0
br i1 %654, label %655, label %656
655: ; preds = %647
br label %660
656: ; preds = %647
br label %657
657: ; preds = %656
%658 = load i32, i32* %17
%659 = add nsw i32 %658, 1
store i32 %659, i32* %17
br label %643
660: ; preds = %655, %643
%661 = load i32, i32* %17
%662 = load i32, i32* %18
%663 = icmp slt i32 %661, %662
br i1 %663, label %664, label %738
664: ; preds = %660
store i32 0, i32* %17
br label %665
665: ; preds = %680, %664
%666 = load i32, i32* %17
%667 = load i32, i32* %18
%668 = icmp slt i32 %666, %667
br i1 %668, label %669, label %683
669: ; preds = %665
%670 = load i8*, i8** %26
%671 = load i32, i32* %17
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds i8, i8* %670, i64 %672
%674 = load i8, i8* %673
%675 = zext i8 %674 to i16
%676 = load i16*, i16** %27
%677 = load i32, i32* %17
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds i16, i16* %676, i64 %678
store i16 %675, i16* %679
br label %680
680: ; preds = %669
%681 = load i32, i32* %17
%682 = add nsw i32 %681, 1
store i32 %682, i32* %17
br label %665
683: ; preds = %665
%684 = load i8*, i8** %14
%685 = load i32, i32* %19
%686 = load i32, i32* %18
%687 = mul nsw i32 %685, %686
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds i8, i8* %684, i64 %688
%690 = load i32, i32* %13
%691 = load i32, i32* %11
%692 = load i32, i32* %12
%693 = load float*, float** %29
%694 = load i32*, i32** %15
%695 = getelementptr inbounds i32, i32* %694, i64 1
%696 = load i32, i32* %695
%697 = load i32*, i32** %16
%698 = getelementptr inbounds i32, i32* %697, i64 1
%699 = load i32, i32* %698
%700 = load i16*, i16** %27
%701 = load i8*, i8** %25
%702 = call i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...) bitcast (i32 (...)* @getJ to i32 (i8*, i32, i32, i32, float*, i32, i32, i16*, i8*, i32, ...)*)(i8* %689, i32 %690, i32 %691, i32 %692, float* %693, i32 %696, i32 %699, i16* %700, i8* %701, i32 1)
%703 = load i16*, i16** %27
%704 = load i32, i32* %11
%705 = load i32, i32* %12
%706 = load i8*, i8** %25
%707 = call i32 (i16*, i32, i32, i32, i8*, ...) bitcast (i32 (...)* @removehole to i32 (i16*, i32, i32, i32, i8*, ...)*)(i16* %703, i32 1, i32 %704, i32 %705, i8* %706)
%708 = load i32**, i32*** %20
%709 = getelementptr inbounds i32*, i32** %708, i64 0
%710 = load i32*, i32** %709
%711 = getelementptr inbounds i32, i32* %710, i64 1
store i32 0, i32* %711
%712 = load i16*, i16** %27
%713 = load float*, float** %29
%714 = load i32, i32* %11
%715 = load i32, i32* %12
%716 = load i8*, i8** %25
%717 = load i32**, i32*** %20
%718 = call i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...) bitcast (i32 (...)* @flood to i32 (i16*, float*, i32, i32, i32, i8*, i32, i32**, ...)*)(i16* %712, float* %713, i32 1, i32 %714, i32 %715, i8* %716, i32 1, i32** %717)
store i32 0, i32* %17
br label %719
719: ; preds = %734, %683
%720 = load i32, i32* %17
%721 = load i32, i32* %18
%722 = icmp slt i32 %720, %721
br i1 %722, label %723, label %737
723: ; preds = %719
%724 = load i16*, i16** %27
%725 = load i32, i32* %17
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds i16, i16* %724, i64 %726
%728 = load i16, i16* %727
%729 = trunc i16 %728 to i8
%730 = load i8*, i8** %26
%731 = load i32, i32* %17
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds i8, i8* %730, i64 %732
store i8 %729, i8* %733
br label %734
734: ; preds = %723
%735 = load i32, i32* %17
%736 = add nsw i32 %735, 1
store i32 %736, i32* %17
br label %719
737: ; preds = %719
br label %738
738: ; preds = %737, %660
%739 = load i32**, i32*** %21
%740 = load i32, i32* %10
%741 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @free_imatrix to i32 (i32**, i32, ...)*)(i32** %739, i32 %740)
%742 = load i8*, i8** %25
%743 = load i16*, i16** %27
%744 = bitcast i16* %743 to i8*
%745 = load i16*, i16** %28
%746 = bitcast i16* %745 to i8*
%747 = load float*, float** %29
%748 = bitcast float* %747 to i8*
%749 = load i32**, i32*** %20
%750 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @free_imatrix to i32 (i32**, i32, ...)*)(i32** %749, i32 1)
ret void
}

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