#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef scalar_t__ int16_t;

/* Variables and functions */
int M_PI;
scalar_t__ calc_filter3x3(scalar_t__, scalar_t__, scalar_t__, scalar_t__,
                          scalar_t__, scalar_t__, scalar_t__, scalar_t__,
                          scalar_t__, scalar_t__ const, scalar_t__ const,
                          scalar_t__ const, scalar_t__ const, scalar_t__ const,
                          scalar_t__ const, scalar_t__ const, scalar_t__ const,
                          scalar_t__ const, int const);
scalar_t__ calc_filterNxN(scalar_t__ const *, int const, int const, int, int,
                          int, scalar_t__ *, int, int, int const);
double expf(int);
scalar_t__ roundf(float);
void filter_gauss_3s16(int16_t *img_gauss, const int16_t *img_in,
                       const int height, const int width, int kernel_size,
                       const float spread, const int skip_ch1,
                       const int skip_ch2, const int skip_ch3) {
  int y, x, index, index_upper, index_center, index_lower;
  int kernel_start, kernel_end;
  float a[25 * 25];
  int16_t a_s16[25 * 25];
  float sum;
  int x_start, x_end, y_start, y_end;
  const int shift_fact = 10;
  if ((kernel_size % 2) == 0) {
    kernel_size++;
  }
  if (kernel_size < 3) {
    kernel_size = 3;
  } else if (kernel_size > 25) {
    kernel_size = 25;
  }
  kernel_start = -1 * kernel_size / 2;
  kernel_end = -1 * kernel_start;
  index = 0;
  sum = 0;
  for (y = kernel_start; y <= kernel_end; y++) {
    for (x = kernel_start; x <= kernel_end; x++) {
      a[index] = (1.0 / (2 * M_PI * spread * spread)) *
                 expf((-1) * ((x * x + y * y) / (2 * spread * spread)));
      sum += a[index];
      index++;
    }
  }
  index = 0;
  for (y = 0; y < kernel_size; y++) {
    for (x = 0; x < kernel_size; x++) {
      a[index] /= sum;
      a_s16[index] = (int16_t)roundf(a[index] * (1 << shift_fact));
      index++;
    }
  }
  y_start = kernel_size / 2;
  y_end = height - y_start;
  x_start = kernel_size / 2;
  x_end = width - x_start;
  for (y = y_start; y < y_end; y++) {
    index = (y * width + x_start) * 3;
    index_upper = (y - 1) * width * 3;
    index_center = y * width * 3;
    index_lower = (y + 1) * width * 3;
    for (x = x_start; x < x_end; x++) {
      if (!skip_ch1) {
        if (kernel_size == 3) {
          img_gauss[index_center] = calc_filter3x3(
              a_s16[0], a_s16[1], a_s16[2], a_s16[3], a_s16[4], a_s16[5],
              a_s16[6], a_s16[7], a_s16[8], img_in[index_upper],
              img_in[index_upper + 3], img_in[index_upper + 6],
              img_in[index_center], img_in[index_center + 3],
              img_in[index_center + 6], img_in[index_lower],
              img_in[index_lower + 3], img_in[index_lower + 6], shift_fact);
        } else {
          img_gauss[index] =
              calc_filterNxN(img_in, height, width, 3, y, x, a_s16, kernel_size,
                             kernel_size, shift_fact);
        }
      } else {
        img_gauss[index] = 0;
      }
      index++;
      index_upper++;
      index_center++;
      index_lower++;
      if (!skip_ch2) {
        if (kernel_size == 3) {
          img_gauss[index_center] = calc_filter3x3(
              a_s16[0], a_s16[1], a_s16[2], a_s16[3], a_s16[4], a_s16[5],
              a_s16[6], a_s16[7], a_s16[8], img_in[index_upper],
              img_in[index_upper + 3], img_in[index_upper + 6],
              img_in[index_center], img_in[index_center + 3],
              img_in[index_center + 6], img_in[index_lower],
              img_in[index_lower + 3], img_in[index_lower + 6], shift_fact);
        } else {
          img_gauss[index] =
              calc_filterNxN(img_in + 1, height, width, 3, y, x, a_s16,
                             kernel_size, kernel_size, shift_fact);
        }
      } else {
        img_gauss[index] = 0;
      }
      index++;
      index_upper++;
      index_center++;
      index_lower++;
      if (!skip_ch3) {
        if (kernel_size == 3) {
          img_gauss[index_center] = calc_filter3x3(
              a_s16[0], a_s16[1], a_s16[2], a_s16[3], a_s16[4], a_s16[5],
              a_s16[6], a_s16[7], a_s16[8], img_in[index_upper],
              img_in[index_upper + 3], img_in[index_upper + 6],
              img_in[index_center], img_in[index_center + 3],
              img_in[index_center + 6], img_in[index_lower],
              img_in[index_lower + 3], img_in[index_lower + 6], shift_fact);
        } else {
          img_gauss[index] =
              calc_filterNxN(img_in + 2, height, width, 3, y, x, a_s16,
                             kernel_size, kernel_size, shift_fact);
        }
      } else {
        img_gauss[index] = 0;
      }
      index++;
      index_upper++;
      index_center++;
      index_lower++;
    }
  }
  index = 0;
  for (y = 0; y < y_start; y++) {
    for (x = 0; x < width; x++) {
      img_gauss[index] = img_in[index];
      img_gauss[index + 1] = img_in[index + 1];
      img_gauss[index + 2] = img_in[index + 2];
      index += 3;
    }
  }
  index = y_end * width * 3;
  for (y = y_end; y < height; y++) {
    for (x = 0; x < width; x++) {
      img_gauss[index] = img_in[index];
      img_gauss[index + 1] = img_in[index + 1];
      img_gauss[index + 2] = img_in[index + 2];
      index += 3;
    }
  }
  for (y = 0; y < height; y++) {
    index = y * width * 3;
    for (x = 0; x < x_start; x++) {
      img_gauss[index] = img_in[index];
      img_gauss[index + 1] = img_in[index + 1];
      img_gauss[index + 2] = img_in[index + 2];
      index += 3;
    }
  }
  for (y = 0; y < height; y++) {
    index = (y * width + x_end) * 3;
    for (x = x_end; x < width; x++) {
      img_gauss[index] = img_in[index];
      img_gauss[index + 1] = img_in[index + 1];
      img_gauss[index + 2] = img_in[index + 2];
      index += 3;
    }
  }
}


x86 assembly (clang, -O0):
<filter_gauss_3s16>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1eb8,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %edx,-0x3c(%rbp)
mov    %ecx,-0x40(%rbp)
mov    %r8d,-0x44(%rbp)
movss  %xmm0,-0x48(%rbp)
mov    %r9d,-0x4c(%rbp)
movl   $0xa,-0x1dd8(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    119c <filter_gauss_3s16+0x5c>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    11b2 <filter_gauss_3s16+0x72>
movl   $0x3,-0x44(%rbp)
jmp    11c8 <filter_gauss_3s16+0x88>
cmpl   $0x19,-0x44(%rbp)
jle    11c3 <filter_gauss_3s16+0x83>
movl   $0x19,-0x44(%rbp)
jmp    11c8 <filter_gauss_3s16+0x88>
imul   $0xffffffff,-0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x68(%rbp)
imul   $0xffffffff,-0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1dc4(%rbp)
ff
mov    -0x68(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     12f2 <filter_gauss_3s16+0x1b2>
mov    -0x68(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     12df <filter_gauss_3s16+0x19f>
mov    0x2dc7(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
mulss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdd0(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1de0(%rbp)
ff
mov    -0x54(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    %ecx,%eax
cvtsi2ss %eax,%xmm1
movss  0xda0(%rip),%xmm0
mulss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
divss  %xmm0,%xmm1
movss  0xd86(%rip),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <expf@plt>
movaps %xmm0,%xmm1
movsd  -0x1de0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x58(%rbp),%rax
movss  %xmm0,-0xa30(%rbp,%rax,4)
ff ff
movslq -0x58(%rbp),%rax
movss  -0xa30(%rbp,%rax,4),%xmm0
ff ff
addss  -0x1dc4(%rbp),%xmm0
ff
movss  %xmm0,-0x1dc4(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    120e <filter_gauss_3s16+0xce>
jmp    12e4 <filter_gauss_3s16+0x1a4>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11fc <filter_gauss_3s16+0xbc>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1394 <filter_gauss_3s16+0x254>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1381 <filter_gauss_3s16+0x241>
movss  -0x1dc4(%rbp),%xmm1
ff
movslq -0x58(%rbp),%rax
movss  -0xa30(%rbp,%rax,4),%xmm0
ff ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xa30(%rbp,%rax,4)
ff ff
movslq -0x58(%rbp),%rax
movss  0xcb3(%rip),%xmm0
mulss  -0xa30(%rbp,%rax,4),%xmm0
ff ff
call   1050 <roundf@plt>
mov    %rax,%rcx
movslq -0x58(%rbp),%rax
mov    %rcx,-0x1dc0(%rbp,%rax,8)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1313 <filter_gauss_3s16+0x1d3>
jmp    1386 <filter_gauss_3s16+0x246>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1300 <filter_gauss_3s16+0x1c0>
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1dd0(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x1dd0(%rbp),%eax
mov    %eax,-0x1dd4(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1dc8(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x1dc8(%rbp),%eax
mov    %eax,-0x1dcc(%rbp)
mov    -0x1dd0(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1dd4(%rbp),%eax
jge    1aa9 <filter_gauss_3s16+0x969>
mov    -0x50(%rbp),%eax
imul   -0x40(%rbp),%eax
add    -0x1dc8(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
imul   -0x40(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
imul   -0x40(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
imul   -0x40(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x64(%rbp)
mov    -0x1dc8(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1dcc(%rbp),%eax
jge    1a96 <filter_gauss_3s16+0x956>
cmpl   $0x0,-0x4c(%rbp)
jne    1624 <filter_gauss_3s16+0x4e4>
cmpl   $0x3,-0x44(%rbp)
jne    15d1 <filter_gauss_3s16+0x491>
mov    -0x1dc0(%rbp),%rdi
mov    -0x1db8(%rbp),%rsi
mov    -0x1db0(%rbp),%rdx
mov    -0x1da8(%rbp),%rax
mov    %rax,-0x1e10(%rbp)
mov    -0x1da0(%rbp),%r8
mov    -0x1d98(%rbp),%r9
mov    -0x1d90(%rbp),%rax
mov    %rax,-0x1e08(%rbp)
mov    -0x1d88(%rbp),%rax
mov    %rax,-0x1e00(%rbp)
mov    -0x1d80(%rbp),%rax
mov    %rax,-0x1df8(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1df0(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r13
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r12
mov    -0x38(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%r15
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r14
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rbx
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%r11
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r10
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1e10(%rbp),%rcx
mov    %rax,-0x1de8(%rbp)
mov    -0x1e08(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x1e00(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x1df8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x1df0(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x1de8(%rbp),%rax
mov    %r13,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
movl   $0xa,0x60(%rsp)
call   1060 <calc_filter3x3@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    161f <filter_gauss_3s16+0x4df>
mov    -0x38(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x50(%rbp),%r8d
mov    -0x54(%rbp),%r9d
lea    -0x1dc0(%rbp),%r11
mov    -0x44(%rbp),%r10d
mov    -0x44(%rbp),%eax
mov    $0x3,%ecx
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0xa,0x18(%rsp)
call   1040 <calc_filterNxN@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1634 <filter_gauss_3s16+0x4f4>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,0x10(%rbp)
jne    183c <filter_gauss_3s16+0x6fc>
cmpl   $0x3,-0x44(%rbp)
jne    17e5 <filter_gauss_3s16+0x6a5>
mov    -0x1dc0(%rbp),%rdi
mov    -0x1db8(%rbp),%rsi
mov    -0x1db0(%rbp),%rdx
mov    -0x1da8(%rbp),%rax
mov    %rax,-0x1e40(%rbp)
mov    -0x1da0(%rbp),%r8
mov    -0x1d98(%rbp),%r9
mov    -0x1d90(%rbp),%rax
mov    %rax,-0x1e38(%rbp)
mov    -0x1d88(%rbp),%rax
mov    %rax,-0x1e30(%rbp)
mov    -0x1d80(%rbp),%rax
mov    %rax,-0x1e28(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1e20(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r13
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r12
mov    -0x38(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%r15
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r14
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rbx
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%r11
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r10
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1e40(%rbp),%rcx
mov    %rax,-0x1e18(%rbp)
mov    -0x1e38(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x1e30(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x1e28(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x1e20(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x1e18(%rbp),%rax
mov    %r13,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
movl   $0xa,0x60(%rsp)
call   1060 <calc_filter3x3@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1837 <filter_gauss_3s16+0x6f7>
mov    -0x38(%rbp),%rdi
add    $0x8,%rdi
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x50(%rbp),%r8d
mov    -0x54(%rbp),%r9d
lea    -0x1dc0(%rbp),%r11
mov    -0x44(%rbp),%r10d
mov    -0x44(%rbp),%eax
mov    $0x3,%ecx
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0xa,0x18(%rsp)
call   1040 <calc_filterNxN@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    184c <filter_gauss_3s16+0x70c>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    1a54 <filter_gauss_3s16+0x914>
cmpl   $0x3,-0x44(%rbp)
jne    19fd <filter_gauss_3s16+0x8bd>
mov    -0x1dc0(%rbp),%rdi
mov    -0x1db8(%rbp),%rsi
mov    -0x1db0(%rbp),%rdx
mov    -0x1da8(%rbp),%rax
mov    %rax,-0x1e70(%rbp)
mov    -0x1da0(%rbp),%r8
mov    -0x1d98(%rbp),%r9
mov    -0x1d90(%rbp),%rax
mov    %rax,-0x1e68(%rbp)
mov    -0x1d88(%rbp),%rax
mov    %rax,-0x1e60(%rbp)
mov    -0x1d80(%rbp),%rax
mov    %rax,-0x1e58(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1e50(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r13
mov    -0x38(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r12
mov    -0x38(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%r15
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r14
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rbx
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%r11
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%r10
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1e70(%rbp),%rcx
mov    %rax,-0x1e48(%rbp)
mov    -0x1e68(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x1e60(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x1e58(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x1e50(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x1e48(%rbp),%rax
mov    %r13,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
movl   $0xa,0x60(%rsp)
call   1060 <calc_filter3x3@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1a4f <filter_gauss_3s16+0x90f>
mov    -0x38(%rbp),%rdi
add    $0x10,%rdi
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x50(%rbp),%r8d
mov    -0x54(%rbp),%r9d
lea    -0x1dc0(%rbp),%r11
mov    -0x44(%rbp),%r10d
mov    -0x44(%rbp),%eax
mov    $0x3,%ecx
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
movl   $0xa,0x18(%rsp)
call   1040 <calc_filterNxN@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1a64 <filter_gauss_3s16+0x924>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1435 <filter_gauss_3s16+0x2f5>
jmp    1a9b <filter_gauss_3s16+0x95b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13dd <filter_gauss_3s16+0x29d>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1dd0(%rbp),%eax
jge    1b5f <filter_gauss_3s16+0xa1f>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1b4c <filter_gauss_3s16+0xa0c>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1acd <filter_gauss_3s16+0x98d>
jmp    1b51 <filter_gauss_3s16+0xa11>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1ab7 <filter_gauss_3s16+0x977>
mov    -0x1dd4(%rbp),%eax
imul   -0x40(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x58(%rbp)
mov    -0x1dd4(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1c1d <filter_gauss_3s16+0xadd>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1c0a <filter_gauss_3s16+0xaca>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1b8b <filter_gauss_3s16+0xa4b>
jmp    1c0f <filter_gauss_3s16+0xacf>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1b78 <filter_gauss_3s16+0xa38>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1cd9 <filter_gauss_3s16+0xb99>
mov    -0x50(%rbp),%eax
imul   -0x40(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1dc8(%rbp),%eax
jge    1cc6 <filter_gauss_3s16+0xb86>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1c44 <filter_gauss_3s16+0xb04>
jmp    1ccb <filter_gauss_3s16+0xb8b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1c24 <filter_gauss_3s16+0xae4>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1d9a <filter_gauss_3s16+0xc5a>
mov    -0x50(%rbp),%eax
imul   -0x40(%rbp),%eax
add    -0x1dcc(%rbp),%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x58(%rbp)
mov    -0x1dcc(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1d87 <filter_gauss_3s16+0xc47>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1d08 <filter_gauss_3s16+0xbc8>
jmp    1d8c <filter_gauss_3s16+0xc4c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1ce0 <filter_gauss_3s16+0xba0>
add    $0x1eb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<filter_gauss_3s16>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e58,%rsp
mov    %r9d,0xc4(%rsp)
movaps %xmm0,%xmm2
mov    %rcx,0x8(%rsp)
mov    %edx,0x4(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %rdi,%r13
mov    %r8d,%eax
not    %eax
and    $0x1,%eax
add    %r8d,%eax
cmp    $0x19,%eax
mov    $0x19,%ecx
cmovl  %eax,%ecx
cmp    $0x4,%ecx
mov    $0x3,%edx
mov    %ecx,0x34(%rsp)
cmovge %ecx,%edx
mov    %edx,%ecx
shr    %ecx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
neg    %eax
movaps %xmm0,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm0,%xmm3
mov    %rdx,0x38(%rsp)
mov    %edx,%ecx
or     $0x1,%ecx
mov    %ecx,0x70(%rsp)
xorps  %xmm1,%xmm1
xor    %ebp,%ebp
mov    0x2e20(%rip),%rbx
movsd  0xe30(%rip),%xmm4
movaps 0xe39(%rip),%xmm5
mov    %eax,0x68(%rsp)
movss  %xmm0,0x28(%rsp)
movss  %xmm3,0x80(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rax,0x78(%rsp)
mov    %eax,%r15d
imul   %eax,%r15d
movslq %ebp,%rbp
mov    0x70(%rsp),%r14d
mov    0x68(%rsp),%r12d
nopl   0x0(%rax)
movss  %xmm1,0x18(%rsp)
mov    (%rbx),%eax
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm0,%xmm4
movsd  %xmm4,0x10(%rsp)
mov    %r12d,%eax
imul   %r12d,%eax
add    %r15d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
xorps  %xmm5,%xmm0
divss  %xmm3,%xmm0
cvttss2si %xmm0,%edi
call   1030 <expf@plt>
movaps 0xdb1(%rip),%xmm5
movsd  0xd99(%rip),%xmm4
movss  0x80(%rsp),%xmm3
movss  0x28(%rsp),%xmm2
movss  0x18(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x1490(%rsp,%rbp,4)
addss  %xmm0,%xmm1
add    $0x1,%rbp
add    $0x1,%r12d
add    $0xffffffff,%r14d
jne    1210 <filter_gauss_3s16+0xd0>
mov    0x78(%rsp),%rdx
lea    0x1(%rdx),%eax
cmp    0x20(%rsp),%edx
jne    11f0 <filter_gauss_3s16+0xb0>
mov    0x38(%rsp),%eax
lea    0x0(,%rax,4),%r12
shl    $0x3,%rax
mov    %rax,0x10(%rsp)
xor    %r15d,%r15d
lea    0x1490(%rsp),%rbx
lea    0x100(%rsp),%rbp
movss  0xd39(%rip),%xmm2
movss  %xmm1,0x18(%rsp)
nopl   (%rax)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%r14,1),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%r14,1)
mulss  %xmm2,%xmm0
call   1050 <roundf@plt>
movss  0xcff(%rip),%xmm2
movss  0x18(%rsp),%xmm1
mov    %rax,0x0(%rbp,%r14,2)
add    $0x4,%r14
cmp    %r14d,%r12d
jne    1300 <filter_gauss_3s16+0x1c0>
add    $0x1,%r15d
add    %r12,%rbx
add    0x10(%rsp),%rbp
cmp    0x38(%rsp),%r15d
jne    12f0 <filter_gauss_3s16+0x1b0>
mov    0x4(%rsp),%r9d
mov    0x20(%rsp),%rax
sub    %eax,%r9d
mov    0x8(%rsp),%rcx
sub    %eax,%ecx
mov    %ecx,0x9c(%rsp)
cmp    %r9d,%eax
jge    1ae6 <filter_gauss_3s16+0x9a6>
mov    0xa0(%rsp),%rcx
lea    0x8(%rcx),%rax
mov    %rax,0xe8(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0xe0(%rsp)
mov    0x8(%rsp),%rsi
lea    0x1(%rsi),%eax
mov    0x20(%rsp),%rdx
imul   %edx,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,0x98(%rsp)
lea    (%rsi,%rsi,2),%eax
mov    %eax,0xb8(%rsp)
lea    -0x1(%rdx),%eax
imul   %esi,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,0x94(%rsp)
mov    %edx,%eax
imul   %esi,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,0x90(%rsp)
lea    0x1(%rdx),%eax
imul   %esi,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,0x8c(%rsp)
lea    0x40(%rcx),%rax
mov    %rax,0xd8(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0xd0(%rsp)
lea    (%rdx,%rdx,1),%eax
mov    %eax,0xb4(%rsp)
mov    %edx,%eax
mov    %r9d,0xbc(%rsp)
jmp    144b <filter_gauss_3s16+0x30b>
nopl   (%rax)
mov    0xb8(%rsp),%eax
add    %eax,0x98(%rsp)
add    %eax,0x94(%rsp)
add    %eax,0x90(%rsp)
add    %eax,0x8c(%rsp)
mov    0xbc(%rsp),%r9d
mov    0xc0(%rsp),%eax
cmp    %r9d,%eax
je     1ae6 <filter_gauss_3s16+0x9a6>
mov    %rax,0x78(%rsp)
add    $0x1,%eax
mov    %eax,0xc0(%rsp)
mov    0x9c(%rsp),%eax
cmp    %eax,0x20(%rsp)
jge    1410 <filter_gauss_3s16+0x2d0>
movslq 0x90(%rsp),%rax
lea    0x2(%rax),%rcx
mov    %rcx,0xf0(%rsp)
movslq 0x98(%rsp),%rsi
mov    %rsi,%rdi
shl    $0x20,%rdi
movabs $0x100000000,%rcx
lea    (%rdi,%rcx,1),%rbx
movabs $0x200000000,%rcx
add    %rcx,%rdi
movslq 0x8c(%rsp),%rcx
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x70(%rsp)
lea    (%rdx,%rax,8),%rcx
mov    %rcx,0x68(%rsp)
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0xc8(%rsp)
movslq 0x94(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0xa8(%rsp)
lea    0x0(,%rsi,8),%rax
add    %r13,%rax
mov    %rax,0x80(%rsp)
mov    0xb4(%rsp),%r12d
xor    %r15d,%r15d
mov    0x20(%rsp),%rax
mov    %eax,%r14d
jmp    15b9 <filter_gauss_3s16+0x479>
mov    0xe8(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdx
mov    $0x3,%ecx
mov    0x78(%rsp),%r8
mov    %r14d,%r9d
push   $0xa
mov    0x40(%rsp),%rax
push   %rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
call   1040 <calc_filterNxN@plt>
add    $0x20,%rsp
mov    0x80(%rsp),%rcx
mov    %rax,0x8(%rcx,%r15,8)
cmpl   $0x0,0x1e98(%rsp)
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%rbx
je     1a9a <filter_gauss_3s16+0x95a>
nopl   (%rax)
mov    %rdi,%rbp
sar    $0x20,%rbp
xor    %eax,%eax
mov    %rax,0x0(%r13,%rbp,8)
add    $0x3,%rsi
add    $0x1,%r14d
add    $0x3,%r15
movabs $0x300000000,%rax
add    %rax,%rbx
add    %rax,%rdi
add    $0x1,%r12d
cmp    %r12d,0x8(%rsp)
je     1410 <filter_gauss_3s16+0x2d0>
cmpl   $0x0,0xc4(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x10(%rsp)
je     1620 <filter_gauss_3s16+0x4e0>
mov    0x80(%rsp),%rax
movq   $0x0,(%rax,%r15,8)
cmpl   $0x0,0x1e90(%rsp)
je     1790 <filter_gauss_3s16+0x650>
mov    %rbx,%rax
sar    $0x1d,%rax
movq   $0x0,0x0(%r13,%rax,1)
cmpl   $0x0,0x1e98(%rsp)
jne    1580 <filter_gauss_3s16+0x440>
cmpl   $0x3,0x34(%rsp)
jle    18d4 <filter_gauss_3s16+0x794>
jmp    1a9a <filter_gauss_3s16+0x95a>
nopl   0x0(%rax)
mov    %rbx,0x28(%rsp)
cmpl   $0x4,0x34(%rsp)
jge    1a1a <filter_gauss_3s16+0x8da>
mov    0x100(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x128(%rsp),%r9
movaps 0x130(%rsp),%xmm0
mov    0x140(%rsp),%r10
mov    0xa8(%rsp),%rax
mov    -0x40(%rax,%r15,8),%r11
mov    -0x28(%rax,%r15,8),%rbx
mov    -0x10(%rax,%r15,8),%r8
mov    0x68(%rsp),%rax
mov    -0x40(%rax,%r15,8),%rbp
mov    -0x28(%rax,%r15,8),%rdi
mov    -0x10(%rax,%r15,8),%rsi
mov    0x70(%rsp),%rax
mov    -0x40(%rax,%r15,8),%rdx
mov    -0x28(%rax,%r15,8),%rcx
mov    -0x10(%rax,%r15,8),%rax
sub    $0x70,%rsp
mov    %rax,0x58(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rbp,0x30(%rsp)
mov    %r8,0x28(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x10(%rsp)
movups %xmm0,(%rsp)
movl   $0xa,0x60(%rsp)
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%r8
mov    0xd0(%rsp),%rsi
mov    0xc8(%rsp),%rdx
mov    0xc0(%rsp),%rcx
call   1060 <calc_filter3x3@plt>
add    $0x70,%rsp
mov    0xc8(%rsp),%rcx
mov    %rax,-0x8(%rcx,%r15,8)
cmpl   $0x0,0x1e90(%rsp)
je     17a0 <filter_gauss_3s16+0x660>
mov    0x28(%rsp),%rbx
mov    %rbx,%rax
sar    $0x1d,%rax
movq   $0x0,0x0(%r13,%rax,1)
cmpl   $0x0,0x1e98(%rsp)
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
jne    1580 <filter_gauss_3s16+0x440>
jmp    18d4 <filter_gauss_3s16+0x794>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,0x28(%rsp)
cmpl   $0x4,0x34(%rsp)
jge    151a <filter_gauss_3s16+0x3da>
mov    0x100(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x128(%rsp),%r9
movaps 0x130(%rsp),%xmm0
mov    0x140(%rsp),%r10
mov    0xa8(%rsp),%rax
mov    -0x38(%rax,%r15,8),%r11
mov    -0x20(%rax,%r15,8),%rbx
mov    -0x8(%rax,%r15,8),%r8
mov    0x68(%rsp),%rax
mov    -0x38(%rax,%r15,8),%rbp
mov    -0x20(%rax,%r15,8),%rdi
mov    -0x8(%rax,%r15,8),%rsi
mov    0x70(%rsp),%rax
mov    -0x38(%rax,%r15,8),%rdx
mov    -0x20(%rax,%r15,8),%rcx
mov    -0x8(%rax,%r15,8),%rax
sub    $0x70,%rsp
mov    %rax,0x58(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rbp,0x30(%rsp)
mov    %r8,0x28(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x10(%rsp)
movups %xmm0,(%rsp)
movl   $0xa,0x60(%rsp)
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%r8
mov    0xd0(%rsp),%rsi
mov    0xc8(%rsp),%rdx
mov    0xc0(%rsp),%rcx
call   1060 <calc_filter3x3@plt>
add    $0x70,%rsp
mov    0xc8(%rsp),%rcx
mov    %rax,(%rcx,%r15,8)
cmpl   $0x0,0x1e98(%rsp)
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%rbx
jne    1580 <filter_gauss_3s16+0x440>
mov    0xf0(%rsp),%rax
lea    (%rax,%r15,1),%rbp
mov    0x100(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x128(%rsp),%rax
mov    %rax,0x40(%rsp)
movaps 0x130(%rsp),%xmm0
mov    0x140(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0xa8(%rsp),%rax
mov    -0x30(%rax,%r15,8),%r11
mov    -0x18(%rax,%r15,8),%r10
mov    (%rax,%r15,8),%r9
mov    0x68(%rsp),%rax
mov    -0x30(%rax,%r15,8),%r8
mov    -0x18(%rax,%r15,8),%rdi
mov    (%rax,%r15,8),%rsi
mov    0x70(%rsp),%rax
mov    -0x30(%rax,%r15,8),%rdx
mov    -0x18(%rax,%r15,8),%rcx
mov    (%rax,%r15,8),%rax
sub    $0x70,%rsp
mov    %rax,0x58(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r8,0x30(%rsp)
mov    %r9,0x28(%rsp)
mov    %r10,0x20(%rsp)
mov    %r11,0x18(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x10(%rsp)
movups %xmm0,(%rsp)
movl   $0xa,0x60(%rsp)
mov    0xc0(%rsp),%rdi
mov    0xb8(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    0x98(%rsp),%rsi
mov    0xd0(%rsp),%rdx
mov    0xc8(%rsp),%rcx
call   1060 <calc_filter3x3@plt>
mov    0x80(%rsp),%rdi
mov    0x88(%rsp),%rsi
add    $0x70,%rsp
jmp    1589 <filter_gauss_3s16+0x449>
mov    0xa0(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdx
mov    $0x3,%ecx
mov    0x78(%rsp),%r8
mov    %r14d,%r9d
push   $0xa
mov    0x40(%rsp),%rax
push   %rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
call   1040 <calc_filterNxN@plt>
add    $0x20,%rsp
mov    0x80(%rsp),%rcx
mov    %rax,(%rcx,%r15,8)
cmpl   $0x0,0x1e90(%rsp)
je     151a <filter_gauss_3s16+0x3da>
mov    0x28(%rsp),%rbx
mov    %rbx,%rax
sar    $0x1d,%rax
movq   $0x0,0x0(%r13,%rax,1)
cmpl   $0x0,0x1e98(%rsp)
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
jne    1580 <filter_gauss_3s16+0x440>
lea    0x2(%rsi),%rbp
mov    0xe0(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdx
mov    $0x3,%ecx
mov    0x78(%rsp),%r8
mov    %r14d,%r9d
push   $0xa
mov    0x40(%rsp),%rax
push   %rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
call   1040 <calc_filterNxN@plt>
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rsi
add    $0x20,%rsp
jmp    1589 <filter_gauss_3s16+0x449>
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%r8d
mov    %eax,%ecx
and    $0xfffffffe,%ecx
xor    %edx,%edx
xor    %esi,%esi
mov    0xa0(%rsp),%rax
jmp    1b1d <filter_gauss_3s16+0x9dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%edx
cmp    0x20(%rsp),%edx
je     1ba1 <filter_gauss_3s16+0xa61>
cmpl   $0x0,0x8(%rsp)
jle    1b10 <filter_gauss_3s16+0x9d0>
movslq %esi,%rsi
test   %r8d,%r8d
je     1b74 <filter_gauss_3s16+0xa34>
mov    %ecx,%edi
xchg   %ax,%ax
mov    (%rax,%rsi,8),%rbp
mov    %rbp,0x0(%r13,%rsi,8)
mov    0x8(%rax,%rsi,8),%rbp
mov    %rbp,0x8(%r13,%rsi,8)
mov    0x10(%rax,%rsi,8),%rbp
mov    %rbp,0x10(%r13,%rsi,8)
mov    0x18(%rax,%rsi,8),%rbp
mov    %rbp,0x18(%r13,%rsi,8)
mov    0x20(%rax,%rsi,8),%rbp
mov    %rbp,0x20(%r13,%rsi,8)
mov    0x28(%rax,%rsi,8),%rbp
mov    %rbp,0x28(%r13,%rsi,8)
add    $0x6,%rsi
add    $0xfffffffe,%edi
jne    1b30 <filter_gauss_3s16+0x9f0>
testb  $0x1,0x8(%rsp)
je     1b10 <filter_gauss_3s16+0x9d0>
mov    (%rax,%rsi,8),%rdi
mov    %rdi,0x0(%r13,%rsi,8)
mov    0x8(%rax,%rsi,8),%rdi
mov    %rdi,0x8(%r13,%rsi,8)
mov    0x10(%rax,%rsi,8),%rdi
mov    %rdi,0x10(%r13,%rsi,8)
add    $0x3,%rsi
jmp    1b10 <filter_gauss_3s16+0x9d0>
mov    0x8(%rsp),%rdx
mov    %edx,%ecx
imul   %r9d,%ecx
lea    (%rcx,%rcx,2),%ecx
and    $0xfffffffe,%edx
jmp    1bcf <filter_gauss_3s16+0xa8f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9d
cmp    0x4(%rsp),%r9d
jge    1c51 <filter_gauss_3s16+0xb11>
cmpl   $0x0,0x8(%rsp)
jle    1bc0 <filter_gauss_3s16+0xa80>
movslq %ecx,%rcx
mov    %edx,%esi
test   %r8d,%r8d
je     1c24 <filter_gauss_3s16+0xae4>
mov    (%rax,%rcx,8),%rdi
mov    %rdi,0x0(%r13,%rcx,8)
mov    0x8(%rax,%rcx,8),%rdi
mov    %rdi,0x8(%r13,%rcx,8)
mov    0x10(%rax,%rcx,8),%rdi
mov    %rdi,0x10(%r13,%rcx,8)
mov    0x18(%rax,%rcx,8),%rdi
mov    %rdi,0x18(%r13,%rcx,8)
mov    0x20(%rax,%rcx,8),%rdi
mov    %rdi,0x20(%r13,%rcx,8)
mov    0x28(%rax,%rcx,8),%rdi
mov    %rdi,0x28(%r13,%rcx,8)
add    $0x6,%rcx
add    $0xfffffffe,%esi
jne    1be0 <filter_gauss_3s16+0xaa0>
testb  $0x1,0x8(%rsp)
je     1bc0 <filter_gauss_3s16+0xa80>
mov    (%rax,%rcx,8),%rsi
mov    %rsi,0x0(%r13,%rcx,8)
mov    0x8(%rax,%rcx,8),%rsi
mov    %rsi,0x8(%r13,%rcx,8)
mov    0x10(%rax,%rcx,8),%rsi
mov    %rsi,0x10(%r13,%rcx,8)
add    $0x3,%rcx
jmp    1bc0 <filter_gauss_3s16+0xa80>
cmpl   $0x0,0x4(%rsp)
jle    1d84 <filter_gauss_3s16+0xc44>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,2),%ebp
mov    0x20(%rsp),%rcx
mov    %ecx,%r8d
and    $0x3ffffffe,%r8d
xor    %edx,%edx
xor    %esi,%esi
jmp    1c90 <filter_gauss_3s16+0xb50>
nopl   0x0(%rax)
add    $0x1,%esi
add    %ebp,%edx
cmp    0x4(%rsp),%esi
mov    0x8(%rsp),%rbx
je     1d0d <filter_gauss_3s16+0xbcd>
movslq %edx,%rdi
cmpl   $0x1,0x20(%rsp)
je     1ce4 <filter_gauss_3s16+0xba4>
mov    %r8d,%ecx
nopl   (%rax)
mov    (%rax,%rdi,8),%rbx
mov    %rbx,0x0(%r13,%rdi,8)
mov    0x8(%rax,%rdi,8),%rbx
mov    %rbx,0x8(%r13,%rdi,8)
mov    0x10(%rax,%rdi,8),%rbx
mov    %rbx,0x10(%r13,%rdi,8)
mov    0x18(%rax,%rdi,8),%rbx
mov    %rbx,0x18(%r13,%rdi,8)
mov    0x20(%rax,%rdi,8),%rbx
mov    %rbx,0x20(%r13,%rdi,8)
mov    0x28(%rax,%rdi,8),%rbx
mov    %rbx,0x28(%r13,%rdi,8)
add    $0x6,%rdi
add    $0xfffffffe,%ecx
jne    1ca0 <filter_gauss_3s16+0xb60>
testb  $0x2,0x38(%rsp)
je     1c80 <filter_gauss_3s16+0xb40>
mov    (%rax,%rdi,8),%rcx
mov    %rcx,0x0(%r13,%rdi,8)
mov    0x8(%rax,%rdi,8),%rcx
mov    %rcx,0x8(%r13,%rdi,8)
mov    0x10(%rax,%rdi,8),%rcx
mov    %rcx,0x10(%r13,%rdi,8)
jmp    1c80 <filter_gauss_3s16+0xb40>
cmpl   $0x0,0x4(%rsp)
jle    1d84 <filter_gauss_3s16+0xc44>
lea    (%rbx,%rbx,2),%r8d
mov    0x20(%rsp),%rcx
lea    (%rcx,%rcx,2),%edx
mov    %r8d,%ecx
sub    %edx,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rsi
lea    0x10(,%rsi,8),%rsi
mov    0x9c(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x10(%rax,%rsi,1),%rbp
mov    %rbp,-0x10(%r13,%rsi,1)
mov    -0x8(%rax,%rsi,1),%rbp
mov    %rbp,-0x8(%r13,%rsi,1)
mov    (%rax,%rsi,1),%rbp
mov    %rbp,0x0(%r13,%rsi,1)
add    $0x1,%edi
add    $0x18,%rsi
cmp    %ebx,%edi
jl     1d50 <filter_gauss_3s16+0xc10>
add    $0x1,%edx
add    %r8d,%ecx
cmp    0x4(%rsp),%edx
jne    1d30 <filter_gauss_3s16+0xbf0>
add    $0x1e58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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