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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ __m128;

/* Variables and functions */
int /*<<< orphan*/ _mm_add_ps(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_load1_ps(float *);
int /*<<< orphan*/ _mm_loadu_ps(float *);
int /*<<< orphan*/ _mm_mul_ps(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_setzero_ps();
int /*<<< orphan*/ _mm_storeu_ps(float *, int /*<<< orphan*/);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(float *);
int conv2D(float *in, float *out, int data_size_X, int data_size_Y,
           float *kernel) {
  int x_pad = 3 / 2;
  int y_pad = 3 / 2;
  float value = 0;
  register int row_jump = 2 * x_pad + data_size_X;
  int padded_in_size = row_jump * (2 * y_pad + data_size_Y);
  int kernel_size = 3 * 3;
  float flat_kernel[3 * 3];
  float *padded_in = (float *)calloc(padded_in_size, sizeof(float));
  __m128 out_vector, x_vector, kernel_vector;
  for (int i = 0; i < kernel_size; i++)
    flat_kernel[i] = kernel[kernel_size - i - 1];
  for (int i = 0; i < data_size_Y; i++)
    for (int j = 0; j < data_size_X; j++)
      padded_in[x_pad + j + row_jump * (i + y_pad)] = in[j + data_size_X * i];
  for (int y = 0; y < data_size_Y; y++) {
    for (int x = 0; x < (data_size_X / 4) * 4; x += 4) {
      out_vector = _mm_setzero_ps();
      for (int i = 0; i < kernel_size / 3 * 3; i += 3) {
        x_vector = _mm_loadu_ps(
            &padded_in[(x_pad + x - (3 - 1) / 2 + (i % 3)) +
                       (y_pad + y - (3 - 1) / 2 + (i / 3)) * row_jump]);
        kernel_vector = _mm_load1_ps(&flat_kernel[i]);
        x_vector = _mm_mul_ps(x_vector, kernel_vector);
        out_vector = _mm_add_ps(out_vector, x_vector);
        x_vector = _mm_loadu_ps(
            &padded_in[(x_pad + x - (3 - 1) / 2 + ((i + 1) % 3)) +
                       (y_pad + y - (3 - 1) / 2 + ((i + 1) / 3)) * row_jump]);
        kernel_vector = _mm_load1_ps(&flat_kernel[i + 1]);
        x_vector = _mm_mul_ps(x_vector, kernel_vector);
        out_vector = _mm_add_ps(out_vector, x_vector);
        x_vector = _mm_loadu_ps(
            &padded_in[(x_pad + x - (3 - 1) / 2 + ((i + 2) % 3)) +
                       (y_pad + y - (3 - 1) / 2 + ((i + 2) / 3)) * row_jump]);
        kernel_vector = _mm_load1_ps(&flat_kernel[i + 2]);
        x_vector = _mm_mul_ps(x_vector, kernel_vector);
        out_vector = _mm_add_ps(out_vector, x_vector);
      }
      for (int i = kernel_size / 3 * 3; i < kernel_size; i++) {
        x_vector = _mm_loadu_ps(
            &padded_in[(x_pad + x - (3 - 1) / 2 + ((i) % 3)) +
                       (y_pad + y - (3 - 1) / 2 + (i / 3)) * row_jump]);
        kernel_vector = _mm_load1_ps(&flat_kernel[i]);
        x_vector = _mm_mul_ps(x_vector, kernel_vector);
        out_vector = _mm_add_ps(out_vector, x_vector);
      }
      _mm_storeu_ps(&out[x + y * data_size_X], out_vector);
    }
    for (int x = (data_size_X / 4) * 4; x < data_size_X; x++, value = 0) {
      for (int i = 0; i < kernel_size; i++)
        value += flat_kernel[i] *
                 padded_in[(x_pad + x - (3 - 1) / 2 + (i % 3)) +
                           (y_pad + y - (3 - 1) / 2 + (i / 3)) * row_jump];
      out[x + y * data_size_X] = value;
    }
  }
  free(padded_in);
  return 1;
}


x86 assembly (clang, -O0):
<conv2D>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    -0x18(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x34(%rbp)
movl   $0x9,-0x38(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1229 <conv2D+0xa9>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    11f0 <conv2D+0x70>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12a8 <conv2D+0x128>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1295 <conv2D+0x115>
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x80(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x7c(%rbp),%esi
add    -0x28(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1243 <conv2D+0xc3>
jmp    129a <conv2D+0x11a>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1230 <conv2D+0xb0>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1786 <conv2D+0x606>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    1659 <conv2D+0x4d9>
mov    $0x0,%al
call   10a0 <_mm_setzero_ps@plt>
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
imul   $0x3,%ecx,%ecx
cmp    %ecx,%eax
jge    1544 <conv2D+0x3c4>
mov    -0x68(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x8c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0xb8(%rbp),%eax
add    %edx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x28(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x8c(%rbp),%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xb4(%rbp),%eax
add    %edx,%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,-0x70(%rbp)
movslq -0x8c(%rbp),%rax
lea    -0x60(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
call   1090 <_mm_load1_ps@plt>
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%edi
mov    -0x74(%rbp),%esi
call   1070 <_mm_mul_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%edi
mov    -0x70(%rbp),%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0xb0(%rbp),%eax
add    %edx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x28(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xac(%rbp),%eax
add    %edx,%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
cltq
lea    -0x60(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
call   1090 <_mm_load1_ps@plt>
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%edi
mov    -0x74(%rbp),%esi
call   1070 <_mm_mul_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%edi
mov    -0x70(%rbp),%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0xa8(%rbp),%eax
add    %edx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x28(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x8c(%rbp),%eax
add    $0x2,%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xa4(%rbp),%eax
add    %edx,%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x2,%eax
cltq
lea    -0x60(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
call   1090 <_mm_load1_ps@plt>
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%edi
mov    -0x74(%rbp),%esi
call   1070 <_mm_mul_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%edi
mov    -0x70(%rbp),%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x8c(%rbp)
jmp    1309 <conv2D+0x189>
mov    -0x38(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0x3,%eax,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    161e <conv2D+0x49e>
mov    -0x68(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x90(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0xc0(%rbp),%eax
add    %edx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x28(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x90(%rbp),%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xbc(%rbp),%eax
add    %edx,%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,-0x70(%rbp)
movslq -0x90(%rbp),%rax
lea    -0x60(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
call   1090 <_mm_load1_ps@plt>
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%edi
mov    -0x74(%rbp),%esi
call   1070 <_mm_mul_ps@plt>
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%edi
mov    -0x70(%rbp),%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1558 <conv2D+0x3d8>
mov    -0x10(%rbp),%rdi
mov    -0x88(%rbp),%eax
mov    -0x84(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x6c(%rbp),%esi
call   1040 <_mm_storeu_ps@plt>
mov    -0x88(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x88(%rbp)
jmp    12cb <conv2D+0x14b>
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
shl    $0x2,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    176d <conv2D+0x5ed>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    172e <conv2D+0x5ae>
movslq -0x98(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x24(%rbp),%ecx
add    -0x94(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x98(%rbp),%eax
mov    $0x3,%esi
cltd
idiv   %esi
add    %edx,%ecx
mov    -0x28(%rbp),%eax
add    -0x84(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x98(%rbp),%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    -0xcc(%rbp),%edx
mov    %eax,%esi
mov    -0xc8(%rbp),%rax
add    %esi,%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1686 <conv2D+0x506>
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    -0x84(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    166d <conv2D+0x4ed>
jmp    1772 <conv2D+0x5f2>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12b2 <conv2D+0x132>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conv2D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r8,%rbp
mov    %ecx,%r15d
mov    %edx,%ebx
mov    %rsi,0x58(%rsp)
mov    %rdi,%r13
lea    0x2(%rbx),%r14d
lea    0x2(%r15),%edi
imul   %r14d,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rdi
movups 0x14(%rbp),%xmm0
shufps $0x1b,%xmm0,%xmm0
movaps %xmm0,0xc0(%rsp)
movups 0x4(%rbp),%xmm0
shufps $0x1b,%xmm0,%xmm0
movaps %xmm0,0xd0(%rsp)
movss  0x0(%rbp),%xmm0
movss  %xmm0,0xe0(%rsp)
test   %r15d,%r15d
jle    1a2b <conv2D+0x8ab>
mov    %rbx,%r9
movslq %r9d,%rax
mov    %rax,0x8(%rsp)
mov    %r14d,0x1c(%rsp)
movslq %r14d,%rax
mov    %rax,0x48(%rsp)
mov    %r15,0x40(%rsp)
mov    %r15d,%eax
mov    %rax,0xb8(%rsp)
mov    %r9d,%eax
lea    0x4(%rdi),%r10
lea    0x4(%rdi,%rax,4),%rcx
mov    %rcx,0x60(%rsp)
lea    0x0(,%rax,4),%r12
add    %r13,%r12
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%r14
mov    %r14,0x80(%rsp)
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
mov    %eax,%r11d
and    $0x3,%r11d
lea    0x34(%rdi),%rcx
mov    %rcx,0x50(%rsp)
lea    0x30(%r13),%rcx
mov    %rcx,0x20(%rsp)
mov    %rdi,(%rsp)
lea    0x10(%rdi),%rcx
mov    %rcx,0x90(%rsp)
lea    0xc(%r13),%rcx
mov    %rcx,0x30(%rsp)
xor    %r15d,%r15d
mov    %rbx,0x10(%rsp)
jmp    12b3 <conv2D+0x133>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r9
cmp    0xb8(%rsp),%r15
je     1466 <conv2D+0x2e6>
test   %r9d,%r9d
jle    13b0 <conv2D+0x230>
mov    %r15,%rdx
imul   0x8(%rsp),%rdx
add    $0x1,%r15
mov    %r15,%rsi
imul   0x48(%rsp),%rsi
cmp    $0x8,%r9d
jb     1306 <conv2D+0x186>
lea    (%r10,%rsi,4),%rcx
lea    (%r12,%rdx,4),%rdi
cmp    %rdi,%rcx
jae    13b9 <conv2D+0x239>
mov    0x60(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
lea    0x0(,%rdx,4),%rdi
add    %r13,%rdi
cmp    %rcx,%rdi
jae    13b9 <conv2D+0x239>
xor    %edi,%edi
mov    %rdi,%r9
not    %r9
add    %rax,%r9
test   %r11,%r11
je     1344 <conv2D+0x1c4>
lea    (%r10,%rsi,4),%rcx
lea    0x0(,%rdx,4),%rbx
add    %r13,%rbx
mov    %r11,%rbp
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbp
jne    1330 <conv2D+0x1b0>
cmp    $0x3,%r9
jb     12a0 <conv2D+0x120>
mov    0x90(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    0x30(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rdx,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rcx,%rdi,4)
movss  -0x8(%rdx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rcx,%rdi,4)
movss  -0x4(%rdx,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rdi,4)
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1370 <conv2D+0x1f0>
jmp    12a0 <conv2D+0x120>
nopl   0x0(%rax)
add    $0x1,%r15
jmp    12a5 <conv2D+0x125>
cmpq   $0x0,0x80(%rsp)
je     145c <conv2D+0x2dc>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rsi,4),%rbp
mov    0x20(%rsp),%rcx
lea    (%rcx,%rdx,4),%rcx
mov    0x70(%rsp),%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdi,4),%xmm0
movups -0x20(%rcx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm1,-0x20(%rbp,%rdi,4)
movups -0x10(%rcx,%rdi,4),%xmm0
movups (%rcx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm1,0x0(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    13f0 <conv2D+0x270>
test   $0x1,%r14b
je     144b <conv2D+0x2cb>
lea    (%rdi,%rdx,1),%rcx
movups 0x0(%r13,%rcx,4),%xmm0
movups 0x10(%r13,%rcx,4),%xmm1
or     $0x1,%rdi
add    %rsi,%rdi
mov    (%rsp),%rcx
movups %xmm0,(%rcx,%rdi,4)
movups %xmm1,0x10(%rcx,%rdi,4)
mov    %r8,%rdi
cmp    %rax,%r8
je     12a5 <conv2D+0x125>
jmp    1308 <conv2D+0x188>
xor    %edi,%edi
test   $0x1,%r14b
jne    1427 <conv2D+0x2a7>
jmp    144b <conv2D+0x2cb>
cmpl   $0x0,0x40(%rsp)
mov    (%rsp),%rdi
jle    1a2b <conv2D+0x8ab>
lea    0x3(%r9),%eax
test   %r9d,%r9d
cmovns %r9d,%eax
and    $0xfffffffc,%eax
mov    %eax,0x40(%rsp)
movslq %eax,%rbx
lea    (%rdi,%rbx,4),%rax
mov    %rax,0xa8(%rsp)
mov    0x48(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    %rax,0xf8(%rsp)
mov    0x8(%rsp),%rax
sub    %rbx,%rax
mov    %rax,0xb0(%rsp)
and    $0xfffffffffffffffc,%rax
lea    (%rax,%rbx,1),%rcx
mov    %rcx,0xe8(%rsp)
lea    0x8(%rdi),%rcx
mov    %rcx,0x100(%rsp)
xor    %ecx,%ecx
mov    %rbx,0x50(%rsp)
mov    %rax,0xf0(%rsp)
jmp    150e <conv2D+0x38e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%r14
add    $0x1,%r14
mov    (%rsp),%rdi
mov    %r14,%rcx
cmp    0xb8(%rsp),%r14
je     1a2b <conv2D+0x8ab>
mov    %rcx,0x20(%rsp)
cmp    $0x4,%r9d
jl     16cd <conv2D+0x54d>
mov    0x20(%rsp),%rax
mov    %rax,%rcx
imul   0x8(%rsp),%rcx
mov    %rcx,0x80(%rsp)
mov    0x1c(%rsp),%ecx
imul   %eax,%ecx
mov    %ecx,0x70(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
call   10a0 <_mm_setzero_ps@plt>
mov    %eax,%r13d
mov    $0xfffffffffffffffd,%r12
lea    0xc0(%rsp),%rbx
mov    0x70(%rsp),%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x3(%r12),%rcx
mov    %rcx,0x90(%rsp)
movzbl %cl,%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
lea    (%rax,%rax,2),%eax
sub    %al,%cl
movzbl %cl,%eax
mov    0x60(%rsp),%r15
or     %r15d,%eax
add    %r14d,%eax
cltq
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
call   1090 <_mm_load1_ps@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm_mul_ps@plt>
mov    %r13d,%edi
mov    %eax,%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,0x30(%rsp)
lea    0x4(%r12),%rax
movzbl %al,%ecx
imul   $0xab,%ecx,%ecx
shr    $0x9,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %cl,%al
movzbl %al,%eax
or     %r15d,%eax
add    %r14d,%eax
cltq
mov    (%rsp),%r13
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,%ebp
lea    0x4(%rbx),%rdi
call   1090 <_mm_load1_ps@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm_mul_ps@plt>
mov    0x30(%rsp),%edi
mov    %eax,%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,0x30(%rsp)
add    $0x5,%r12
movzbl %r12b,%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
lea    (%rax,%rax,2),%eax
sub    %al,%r12b
movzbl %r12b,%eax
or     %r15d,%eax
add    %r14d,%eax
cltq
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
call   1050 <_mm_loadu_ps@plt>
mov    %eax,%ebp
lea    0x8(%rbx),%rdi
call   1090 <_mm_load1_ps@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm_mul_ps@plt>
mov    0x30(%rsp),%edi
mov    %eax,%esi
call   1080 <_mm_add_ps@plt>
mov    %eax,%r13d
add    0x1c(%rsp),%r14d
add    $0xc,%rbx
mov    0x90(%rsp),%rax
mov    %rax,%r12
cmp    $0x6,%rax
jb     1570 <conv2D+0x3f0>
mov    0x80(%rsp),%rax
mov    0x60(%rsp),%rbp
add    %rbp,%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    %r13d,%esi
call   1040 <_mm_storeu_ps@plt>
add    $0x4,%rbp
mov    0x50(%rsp),%rbx
cmp    %rbx,%rbp
mov    %rbp,%rax
jl     1540 <conv2D+0x3c0>
mov    0x10(%rsp),%r9
cmp    %r9d,0x40(%rsp)
jge    14f0 <conv2D+0x370>
mov    0x20(%rsp),%rdi
mov    %rdi,%r9
imul   0x8(%rsp),%r9
mov    %rdi,%r12
mov    0x48(%rsp),%rax
imul   %rax,%r12
lea    0x1(%rdi),%r14
mov    %r14,%r8
imul   %rax,%r8
add    $0x2,%rdi
imul   %rax,%rdi
movss  0xc0(%rsp),%xmm8
movss  0xc4(%rsp),%xmm13
movss  0xc8(%rsp),%xmm14
movss  0xcc(%rsp),%xmm15
movss  0xd0(%rsp),%xmm4
movss  0xd4(%rsp),%xmm5
movss  0xd8(%rsp),%xmm6
movss  0xdc(%rsp),%xmm7
movss  0xe0(%rsp),%xmm0
mov    %rbx,%rax
cmpq   $0x4,0xb0(%rsp)
jb     1950 <conv2D+0x7d0>
lea    (%r9,%rbx,1),%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%r15
mov    %r14,%rax
imul   0x8(%rsp),%rax
lea    (%rcx,%rax,4),%rax
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rdi,4),%r11
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rdi,4),%rbp
lea    (%rdx,%r8,4),%r10
cmp    %rbp,%r15
lea    (%rcx,%r8,4),%rbp
setb   %sil
cmp    %rax,%r11
setb   %r11b
cmp    %rbp,%r15
lea    (%rcx,%r12,4),%rcx
setb   %r13b
cmp    %rax,%r10
setb   %r10b
cmp    %rcx,%r15
lea    (%rdx,%r12,4),%rbp
setb   %cl
cmp    %rax,%rbp
setb   %dl
mov    %rbx,%rax
test   %r11b,%sil
jne    1950 <conv2D+0x7d0>
mov    %rbx,%rax
and    %r10b,%r13b
jne    1950 <conv2D+0x7d0>
mov    %rbx,%rax
and    %dl,%cl
jne    1950 <conv2D+0x7d0>
movaps %xmm8,%xmm1
shufps $0x0,%xmm8,%xmm1
movaps %xmm1,0x90(%rsp)
movaps %xmm13,%xmm1
shufps $0x0,%xmm13,%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm14,%xmm1
shufps $0x0,%xmm14,%xmm1
movaps %xmm1,0x60(%rsp)
movaps %xmm15,%xmm1
shufps $0x0,%xmm15,%xmm1
movaps %xmm1,0x80(%rsp)
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
movaps %xmm1,0x70(%rsp)
movaps %xmm5,%xmm1
shufps $0x0,%xmm5,%xmm1
movaps %xmm1,0x20(%rsp)
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
movaps %xmm7,%xmm9
shufps $0x0,%xmm7,%xmm9
movaps %xmm0,%xmm10
shufps $0x0,%xmm0,%xmm10
mov    0xa8(%rsp),%rax
lea    (%rax,%r12,4),%rbp
add    $0x8,%rbp
lea    (%rax,%r8,4),%rdx
add    $0x8,%rdx
lea    (%rax,%rdi,4),%rax
add    $0x8,%rax
xor    %ecx,%ecx
mov    0xf0(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movups -0x8(%rbp,%rcx,4),%xmm11
mulps  0x90(%rsp),%xmm11
addps  0x749(%rip),%xmm11
movups -0x4(%rbp,%rcx,4),%xmm12
mulps  0x30(%rsp),%xmm12
addps  %xmm11,%xmm12
movups 0x0(%rbp,%rcx,4),%xmm1
mulps  0x60(%rsp),%xmm1
addps  %xmm12,%xmm1
movups -0x8(%rdx,%rcx,4),%xmm2
mulps  0x80(%rsp),%xmm2
addps  %xmm1,%xmm2
movups -0x4(%rdx,%rcx,4),%xmm1
mulps  0x70(%rsp),%xmm1
addps  %xmm2,%xmm1
movups (%rdx,%rcx,4),%xmm2
mulps  0x20(%rsp),%xmm2
addps  %xmm1,%xmm2
movups -0x8(%rax,%rcx,4),%xmm1
mulps  %xmm3,%xmm1
addps  %xmm2,%xmm1
movups -0x4(%rax,%rcx,4),%xmm2
mulps  %xmm9,%xmm2
addps  %xmm1,%xmm2
movups (%rax,%rcx,4),%xmm1
mulps  %xmm10,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,(%r15,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    18a0 <conv2D+0x720>
mov    0xe8(%rsp),%rax
cmp    %rsi,0xb0(%rsp)
je     1a21 <conv2D+0x8a1>
nopl   0x0(%rax,%rax,1)
add    %rax,%rdi
mov    0x100(%rsp),%rcx
lea    (%rcx,%rdi,4),%rdi
add    %rax,%r8
lea    (%rcx,%r8,4),%rsi
add    %rax,%r12
lea    (%rcx,%r12,4),%rdx
add    %rax,%r9
mov    0x58(%rsp),%rcx
lea    (%rcx,%r9,4),%rcx
mov    0x8(%rsp),%rbp
sub    %rax,%rbp
xor    %eax,%eax
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
movss  -0x8(%rdx,%rax,4),%xmm1
mulss  %xmm8,%xmm1
addss  %xmm3,%xmm1
movss  -0x4(%rdx,%rax,4),%xmm2
mulss  %xmm13,%xmm2
addss  %xmm1,%xmm2
movss  (%rdx,%rax,4),%xmm1
mulss  %xmm14,%xmm1
addss  %xmm2,%xmm1
movss  -0x8(%rsi,%rax,4),%xmm2
mulss  %xmm15,%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rsi,%rax,4),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm2,%xmm1
movss  (%rsi,%rax,4),%xmm2
mulss  %xmm5,%xmm2
addss  %xmm1,%xmm2
movss  -0x8(%rdi,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  %xmm2,%xmm1
movss  -0x4(%rdi,%rax,4),%xmm2
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
movss  (%rdi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1990 <conv2D+0x810>
mov    0x10(%rsp),%r9
jmp    14f9 <conv2D+0x379>
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @conv2D(float* %0, float* %1, i32 %2, i32 %3, float* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca [9 x float]
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store float* %4, float** %10
store i32 1, i32* %11
store i32 1, i32* %12
store float 0.000000e+00, float* %13
%31 = load i32, i32* %11
%32 = mul nsw i32 2, %31
%33 = load i32, i32* %8
%34 = add nsw i32 %32, %33
store i32 %34, i32* %14
%35 = load i32, i32* %14
%36 = load i32, i32* %12
%37 = mul nsw i32 2, %36
%38 = load i32, i32* %9
%39 = add nsw i32 %37, %38
%40 = mul nsw i32 %35, %39
store i32 %40, i32* %15
store i32 9, i32* %16
%41 = load i32, i32* %15
%42 = call i64 @calloc(i32 %41, i32 4)
%43 = inttoptr i64 %42 to float*
store float* %43, float** %18
store i32 0, i32* %22
br label %44
44: ; preds = %60, %5
%45 = load i32, i32* %22
%46 = load i32, i32* %16
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %63
48: ; preds = %44
%49 = load float*, float** %10
%50 = load i32, i32* %16
%51 = load i32, i32* %22
%52 = sub nsw i32 %50, %51
%53 = sub nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %49, i64 %54
%56 = load float, float* %55
%57 = load i32, i32* %22
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %58
store float %56, float* %59
br label %60
60: ; preds = %48
%61 = load i32, i32* %22
%62 = add nsw i32 %61, 1
store i32 %62, i32* %22
br label %44
63: ; preds = %44
store i32 0, i32* %23
br label %64
64: ; preds = %99, %63
%65 = load i32, i32* %23
%66 = load i32, i32* %9
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %102
68: ; preds = %64
store i32 0, i32* %24
br label %69
69: ; preds = %95, %68
%70 = load i32, i32* %24
%71 = load i32, i32* %8
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %98
73: ; preds = %69
%74 = load float*, float** %6
%75 = load i32, i32* %24
%76 = load i32, i32* %8
%77 = load i32, i32* %23
%78 = mul nsw i32 %76, %77
%79 = add nsw i32 %75, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %74, i64 %80
%82 = load float, float* %81
%83 = load float*, float** %18
%84 = load i32, i32* %11
%85 = load i32, i32* %24
%86 = add nsw i32 %84, %85
%87 = load i32, i32* %14
%88 = load i32, i32* %23
%89 = load i32, i32* %12
%90 = add nsw i32 %88, %89
%91 = mul nsw i32 %87, %90
%92 = add nsw i32 %86, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %83, i64 %93
store float %82, float* %94
br label %95
95: ; preds = %73
%96 = load i32, i32* %24
%97 = add nsw i32 %96, 1
store i32 %97, i32* %24
br label %69
98: ; preds = %69
br label %99
99: ; preds = %98
%100 = load i32, i32* %23
%101 = add nsw i32 %100, 1
store i32 %101, i32* %23
br label %64
102: ; preds = %64
store i32 0, i32* %25
br label %103
103: ; preds = %340, %102
%104 = load i32, i32* %25
%105 = load i32, i32* %9
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %343
107: ; preds = %103
store i32 0, i32* %26
br label %108
108: ; preds = %279, %107
%109 = load i32, i32* %26
%110 = load i32, i32* %8
%111 = sdiv i32 %110, 4
%112 = mul nsw i32 %111, 4
%113 = icmp slt i32 %109, %112
br i1 %113, label %114, label %282
114: ; preds = %108
%115 = call i32 (...) @_mm_setzero_ps()
store i32 %115, i32* %19
store i32 0, i32* %27
br label %116
116: ; preds = %222, %114
%117 = load i32, i32* %27
%118 = load i32, i32* %16
%119 = sdiv i32 %118, 3
%120 = mul nsw i32 %119, 3
%121 = icmp slt i32 %117, %120
br i1 %121, label %122, label %225
122: ; preds = %116
%123 = load float*, float** %18
%124 = load i32, i32* %11
%125 = load i32, i32* %26
%126 = add nsw i32 %124, %125
%127 = sub nsw i32 %126, 1
%128 = load i32, i32* %27
%129 = srem i32 %128, 3
%130 = add nsw i32 %127, %129
%131 = load i32, i32* %12
%132 = load i32, i32* %25
%133 = add nsw i32 %131, %132
%134 = sub nsw i32 %133, 1
%135 = load i32, i32* %27
%136 = sdiv i32 %135, 3
%137 = add nsw i32 %134, %136
%138 = load i32, i32* %14
%139 = mul nsw i32 %137, %138
%140 = add nsw i32 %130, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %123, i64 %141
%143 = call i32 @_mm_loadu_ps(float* %142)
store i32 %143, i32* %20
%144 = load i32, i32* %27
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %145
%147 = call i32 @_mm_load1_ps(float* %146)
store i32 %147, i32* %21
%148 = load i32, i32* %20
%149 = load i32, i32* %21
%150 = call i32 @_mm_mul_ps(i32 %148, i32 %149)
store i32 %150, i32* %20
%151 = load i32, i32* %19
%152 = load i32, i32* %20
%153 = call i32 @_mm_add_ps(i32 %151, i32 %152)
store i32 %153, i32* %19
%154 = load float*, float** %18
%155 = load i32, i32* %11
%156 = load i32, i32* %26
%157 = add nsw i32 %155, %156
%158 = sub nsw i32 %157, 1
%159 = load i32, i32* %27
%160 = add nsw i32 %159, 1
%161 = srem i32 %160, 3
%162 = add nsw i32 %158, %161
%163 = load i32, i32* %12
%164 = load i32, i32* %25
%165 = add nsw i32 %163, %164
%166 = sub nsw i32 %165, 1
%167 = load i32, i32* %27
%168 = add nsw i32 %167, 1
%169 = sdiv i32 %168, 3
%170 = add nsw i32 %166, %169
%171 = load i32, i32* %14
%172 = mul nsw i32 %170, %171
%173 = add nsw i32 %162, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %154, i64 %174
%176 = call i32 @_mm_loadu_ps(float* %175)
store i32 %176, i32* %20
%177 = load i32, i32* %27
%178 = add nsw i32 %177, 1
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %179
%181 = call i32 @_mm_load1_ps(float* %180)
store i32 %181, i32* %21
%182 = load i32, i32* %20
%183 = load i32, i32* %21
%184 = call i32 @_mm_mul_ps(i32 %182, i32 %183)
store i32 %184, i32* %20
%185 = load i32, i32* %19
%186 = load i32, i32* %20
%187 = call i32 @_mm_add_ps(i32 %185, i32 %186)
store i32 %187, i32* %19
%188 = load float*, float** %18
%189 = load i32, i32* %11
%190 = load i32, i32* %26
%191 = add nsw i32 %189, %190
%192 = sub nsw i32 %191, 1
%193 = load i32, i32* %27
%194 = add nsw i32 %193, 2
%195 = srem i32 %194, 3
%196 = add nsw i32 %192, %195
%197 = load i32, i32* %12
%198 = load i32, i32* %25
%199 = add nsw i32 %197, %198
%200 = sub nsw i32 %199, 1
%201 = load i32, i32* %27
%202 = add nsw i32 %201, 2
%203 = sdiv i32 %202, 3
%204 = add nsw i32 %200, %203
%205 = load i32, i32* %14
%206 = mul nsw i32 %204, %205
%207 = add nsw i32 %196, %206
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %188, i64 %208
%210 = call i32 @_mm_loadu_ps(float* %209)
store i32 %210, i32* %20
%211 = load i32, i32* %27
%212 = add nsw i32 %211, 2
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %213
%215 = call i32 @_mm_load1_ps(float* %214)
store i32 %215, i32* %21
%216 = load i32, i32* %20
%217 = load i32, i32* %21
%218 = call i32 @_mm_mul_ps(i32 %216, i32 %217)
store i32 %218, i32* %20
%219 = load i32, i32* %19
%220 = load i32, i32* %20
%221 = call i32 @_mm_add_ps(i32 %219, i32 %220)
store i32 %221, i32* %19
br label %222
222: ; preds = %122
%223 = load i32, i32* %27
%224 = add nsw i32 %223, 3
store i32 %224, i32* %27
br label %116
225: ; preds = %116
%226 = load i32, i32* %16
%227 = sdiv i32 %226, 3
%228 = mul nsw i32 %227, 3
store i32 %228, i32* %28
br label %229
229: ; preds = %265, %225
%230 = load i32, i32* %28
%231 = load i32, i32* %16
%232 = icmp slt i32 %230, %231
br i1 %232, label %233, label %268
233: ; preds = %229
%234 = load float*, float** %18
%235 = load i32, i32* %11
%236 = load i32, i32* %26
%237 = add nsw i32 %235, %236
%238 = sub nsw i32 %237, 1
%239 = load i32, i32* %28
%240 = srem i32 %239, 3
%241 = add nsw i32 %238, %240
%242 = load i32, i32* %12
%243 = load i32, i32* %25
%244 = add nsw i32 %242, %243
%245 = sub nsw i32 %244, 1
%246 = load i32, i32* %28
%247 = sdiv i32 %246, 3
%248 = add nsw i32 %245, %247
%249 = load i32, i32* %14
%250 = mul nsw i32 %248, %249
%251 = add nsw i32 %241, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %234, i64 %252
%254 = call i32 @_mm_loadu_ps(float* %253)
store i32 %254, i32* %20
%255 = load i32, i32* %28
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %256
%258 = call i32 @_mm_load1_ps(float* %257)
store i32 %258, i32* %21
%259 = load i32, i32* %20
%260 = load i32, i32* %21
%261 = call i32 @_mm_mul_ps(i32 %259, i32 %260)
store i32 %261, i32* %20
%262 = load i32, i32* %19
%263 = load i32, i32* %20
%264 = call i32 @_mm_add_ps(i32 %262, i32 %263)
store i32 %264, i32* %19
br label %265
265: ; preds = %233
%266 = load i32, i32* %28
%267 = add nsw i32 %266, 1
store i32 %267, i32* %28
br label %229
268: ; preds = %229
%269 = load float*, float** %7
%270 = load i32, i32* %26
%271 = load i32, i32* %25
%272 = load i32, i32* %8
%273 = mul nsw i32 %271, %272
%274 = add nsw i32 %270, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %269, i64 %275
%277 = load i32, i32* %19
%278 = call i32 @_mm_storeu_ps(float* %276, i32 %277)
br label %279
279: ; preds = %268
%280 = load i32, i32* %26
%281 = add nsw i32 %280, 4
store i32 %281, i32* %26
br label %108
282: ; preds = %108
%283 = load i32, i32* %8
%284 = sdiv i32 %283, 4
%285 = mul nsw i32 %284, 4
store i32 %285, i32* %29
br label %286
286: ; preds = %336, %282
%287 = load i32, i32* %29
%288 = load i32, i32* %8
%289 = icmp slt i32 %287, %288
br i1 %289, label %290, label %339
290: ; preds = %286
store i32 0, i32* %30
br label %291
291: ; preds = %323, %290
%292 = load i32, i32* %30
%293 = load i32, i32* %16
%294 = icmp slt i32 %292, %293
br i1 %294, label %295, label %326
295: ; preds = %291
%296 = load i32, i32* %30
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [9 x float], [9 x float]* %17, i64 0, i64 %297
%299 = load float, float* %298
%300 = load float*, float** %18
%301 = load i32, i32* %11
%302 = load i32, i32* %29
%303 = add nsw i32 %301, %302
%304 = sub nsw i32 %303, 1
%305 = load i32, i32* %30
%306 = srem i32 %305, 3
%307 = add nsw i32 %304, %306
%308 = load i32, i32* %12
%309 = load i32, i32* %25
%310 = add nsw i32 %308, %309
%311 = sub nsw i32 %310, 1
%312 = load i32, i32* %30
%313 = sdiv i32 %312, 3
%314 = add nsw i32 %311, %313
%315 = load i32, i32* %14
%316 = mul nsw i32 %314, %315
%317 = add nsw i32 %307, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %300, i64 %318
%320 = load float, float* %319
%321 = load float, float* %13
%322 = call float @llvm.fmuladd.f32(float %299, float %320, float %321)
store float %322, float* %13
br label %323
323: ; preds = %295
%324 = load i32, i32* %30
%325 = add nsw i32 %324, 1
store i32 %325, i32* %30
br label %291
326: ; preds = %291
%327 = load float, float* %13
%328 = load float*, float** %7
%329 = load i32, i32* %29
%330 = load i32, i32* %25
%331 = load i32, i32* %8
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %328, i64 %334
store float %327, float* %335
br label %336
336: ; preds = %326
%337 = load i32, i32* %29
%338 = add nsw i32 %337, 1
store i32 %338, i32* %29
store float 0.000000e+00, float* %13
br label %286
339: ; preds = %286
br label %340
340: ; preds = %339
%341 = load i32, i32* %25
%342 = add nsw i32 %341, 1
store i32 %342, i32* %25
br label %103
343: ; preds = %103
%344 = load float*, float** %18
%345 = call i32 @free(float* %344)
ret i32 1
}

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