#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 */

/* Variables and functions */
float relu(float);
int convolution_filter(float *inputs, float *outputs,
                       unsigned int input_channel, unsigned int intput_columns,
                       unsigned int output_channel, unsigned int output_columns,
                       unsigned int filter_rows, unsigned int filter_cols,
                       unsigned int stride_row, unsigned int stride_col,
                       float *weights, float *biases, char relu_activation) {
  unsigned int out_ch;
  unsigned int in_ch;
  unsigned int current_filter_row;
  unsigned int current_filter_col;
  float current_weight;
  float current_biase;
  float current_input;
  float current_result;
  float kernel_result;
  unsigned int kernel_output_addr;
  for (current_filter_row = 0; current_filter_row < filter_rows;
       current_filter_row++) {
    for (current_filter_col = 0; current_filter_col < filter_cols;
         current_filter_col++) {
      for (in_ch = 0; in_ch < input_channel; in_ch++) {
        current_input =
            ((float *)
                 inputs)[((stride_row + current_filter_row) * intput_columns *
                          input_channel) +
                         ((stride_col + current_filter_col) * input_channel) +
                         in_ch];
        for (out_ch = 0; out_ch < output_channel; out_ch++) {
          current_weight =
              ((float *)weights)[(current_filter_row * filter_cols *
                                  input_channel * output_channel) +
                                 (current_filter_col * input_channel *
                                  output_channel) +
                                 (in_ch * output_channel) + out_ch];
          current_result = current_input * current_weight;
          ((float *)outputs)[(stride_row * output_columns * output_channel) +
                             (stride_col * output_channel) + out_ch] +=
              current_result;
        }
      }
    }
  }
  for (out_ch = 0; out_ch < output_channel; out_ch++) {
    current_biase = ((float *)biases)[out_ch];
    kernel_output_addr = (stride_row * output_columns * output_channel) +
                         (stride_col * output_channel) + out_ch;
    kernel_result = ((float *)outputs)[kernel_output_addr];
    kernel_result += current_biase;
    if (relu_activation) {
      kernel_result = relu(kernel_result);
    }
    ((float *)outputs)[kernel_output_addr] = kernel_result;
  }
  return 0;
}


x86 assembly (clang, -O0):
<convolution_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x40(%rbp),%al
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jae    1278 <convolution_filter+0x168>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x18(%rbp),%eax
jae    1265 <convolution_filter+0x155>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1252 <convolution_filter+0x142>
mov    -0x8(%rbp),%rax
mov    0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    0x28(%rbp),%edx
add    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    123f <convolution_filter+0x12f>
mov    0x30(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x28(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    0x28(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b2 <convolution_filter+0xa2>
jmp    1244 <convolution_filter+0x134>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1172 <convolution_filter+0x62>
jmp    1257 <convolution_filter+0x147>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115f <convolution_filter+0x4f>
jmp    126a <convolution_filter+0x15a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114c <convolution_filter+0x3c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    130e <convolution_filter+0x1fe>
mov    0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
cmpb   $0x0,0x40(%rbp)
je     12ef <convolution_filter+0x1df>
movss  -0x44(%rbp),%xmm0
call   1030 <relu@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    127f <convolution_filter+0x16f>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolution_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9d,0x8(%rsp)
mov    %ecx,0x44(%rsp)
mov    %edx,0x4(%rsp)
mov    %rsi,%rbx
mov    %r8d,%r9d
cmpl   $0x0,0x120(%rsp)
mov    %r9,0x50(%rsp)
je     15d9 <convolution_filter+0x4c9>
mov    0x140(%rsp),%r15
mov    0x128(%rsp),%eax
mov    0x130(%rsp),%ecx
mov    %ecx,%edx
imul   0x8(%rsp),%edx
add    0x138(%rsp),%edx
imul   %r8d,%edx
mov    0x4(%rsp),%ecx
mov    %ecx,%esi
mov    %rsi,0xe0(%rsp)
lea    -0x1(%r9),%rsi
imul   %r8d,%eax
imul   %ecx,%eax
mov    %rax,0x48(%rsp)
mov    %r8d,%eax
imul   %ecx,%eax
mov    %rax,0x58(%rsp)
lea    (%r9,%rdx,1),%rcx
lea    (%rbx,%rcx,4),%rax
mov    %rax,0x98(%rsp)
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x90(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %edx,%ecx
add    %esi,%ecx
setb   %cl
mov    %rsi,0xb8(%rsp)
shr    $0x20,%rsi
mov    %rsi,0xb0(%rsp)
setne  %al
or     %cl,%al
mov    %al,0x3(%rsp)
mov    %rbp,%rax
mov    %rbp,0x80(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x78(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0xc8(%rsp)
mov    %rdx,0x20(%rsp)
lea    (%rbx,%rdx,4),%rax
mov    %rax,0xa8(%rsp)
lea    (%r15,%r9,4),%rax
mov    %rax,0xa0(%rsp)
movl   $0x8,0x10(%rsp)
movl   $0x1,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
jmp    1284 <convolution_filter+0x174>
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
mov    0x48(%rsp),%rax
add    %eax,0x10(%rsp)
add    %eax,0xc(%rsp)
mov    0x30(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0x30(%rsp)
mov    %rdx,0x28(%rsp)
cmp    0x120(%rsp),%edx
je     15d9 <convolution_filter+0x4c9>
cmpl   $0x0,0x128(%rsp)
je     1250 <convolution_filter+0x140>
mov    0x28(%rsp),%rax
mov    %rax,%rcx
imul   0x48(%rsp),%rcx
mov    %rcx,0x70(%rsp)
mov    0x130(%rsp),%ecx
add    %eax,%ecx
imul   0x44(%rsp),%ecx
add    0x138(%rsp),%ecx
mov    %rcx,0x68(%rsp)
imul   0x128(%rsp),%eax
mov    %rax,0x60(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,0x1c(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0x10(%rsp),%eax
mov    %eax,0x14(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
jmp    131c <convolution_filter+0x20c>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
mov    0x58(%rsp),%rax
add    %eax,0x14(%rsp)
add    %eax,0x18(%rsp)
add    %eax,0x1c(%rsp)
mov    %rcx,0x38(%rsp)
cmp    0x128(%rsp),%ecx
je     1250 <convolution_filter+0x140>
cmpl   $0x0,0x4(%rsp)
je     12f0 <convolution_filter+0x1e0>
mov    0x38(%rsp),%rdx
mov    %rdx,%rax
imul   0x58(%rsp),%rax
add    0x70(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x68(%rsp),%rax
add    %edx,%eax
mov    0x4(%rsp),%ecx
imul   %ecx,%eax
mov    %rax,0xd8(%rsp)
mov    0x60(%rsp),%rax
add    %edx,%eax
imul   %ecx,%eax
mov    %rax,0xd0(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,%r14d
mov    0x18(%rsp),%eax
mov    %eax,%r11d
mov    0x14(%rsp),%r13d
xor    %r12d,%r12d
jmp    139b <convolution_filter+0x28b>
xchg   %ax,%ax
add    $0x1,%r12
add    %r8d,%r13d
add    %r8d,%r11d
add    %r8d,%r14d
cmp    0xe0(%rsp),%r12
je     12f0 <convolution_filter+0x1e0>
test   %r8d,%r8d
je     1380 <convolution_filter+0x270>
mov    0xd8(%rsp),%rax
lea    (%rax,%r12,1),%ecx
movss  (%rdi,%rcx,4),%xmm0
mov    0xd0(%rsp),%rax
lea    (%rax,%r12,1),%r10d
imul   %r8d,%r10d
cmp    $0x8,%r8d
jb     1430 <convolution_filter+0x320>
mov    %r12d,%ecx
imul   %r9d,%ecx
mov    0xc0(%rsp),%rax
lea    (%rax,%rcx,1),%edx
cmpq   $0x0,0xb0(%rsp)
setne  %sil
add    0xb8(%rsp),%edx
setb   %dl
or     %sil,%dl
or     0x3(%rsp),%dl
jne    1430 <convolution_filter+0x320>
add    %eax,%ecx
mov    0xa0(%rsp),%rax
lea    (%rax,%rcx,4),%rdx
cmp    %rdx,0xa8(%rsp)
jae    14d5 <convolution_filter+0x3c5>
lea    (%r15,%rcx,4),%rcx
cmp    0x98(%rsp),%rcx
jae    14d5 <convolution_filter+0x3c5>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%r9b
je     1461 <convolution_filter+0x351>
add    %ecx,%r10d
movss  (%r15,%r10,4),%xmm1
mulss  %xmm0,%xmm1
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,1),%edx
addss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0xc8(%rsp),%rcx
je     1380 <convolution_filter+0x270>
lea    (%r11,%rdx,1),%esi
mov    0x20(%rsp),%rax
add    %edx,%eax
mov    %r9,%rbp
sub    %rdx,%rbp
lea    (%r14,%rdx,1),%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%edx
movss  (%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
mov    %eax,%edx
addss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
mov    %esi,%edx
movss  (%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
lea    0x1(%rax),%edx
addss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
add    $0x2,%esi
add    $0x2,%eax
add    $0x2,%ecx
add    $0xfffffffffffffffe,%rbp
jne    1490 <convolution_filter+0x380>
jmp    1380 <convolution_filter+0x270>
mov    %rdi,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x88(%rsp)
je     15cb <convolution_filter+0x4bb>
mov    0x78(%rsp),%rsi
mov    0x20(%rsp),%r9
mov    %r13d,%ebp
xor    %edi,%edi
nopl   (%rax)
lea    -0x8(%rbp),%ecx
movups (%r15,%rcx,4),%xmm2
movups 0x10(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
mov    %r9d,%ecx
movups (%rbx,%rcx,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%rbx,%rcx,4),%xmm2
addps  %xmm3,%xmm2
movups %xmm4,(%rbx,%rcx,4)
movups %xmm2,0x10(%rbx,%rcx,4)
mov    %ebp,%ecx
movups (%r15,%rcx,4),%xmm2
movups 0x10(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
lea    0x8(%r9),%ecx
movups (%rbx,%rcx,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%rbx,%rcx,4),%xmm2
addps  %xmm3,%xmm2
movups %xmm4,(%rbx,%rcx,4)
movups %xmm2,0x10(%rbx,%rcx,4)
add    $0x10,%rdi
add    $0x10,%ebp
add    $0x10,%r9d
add    $0xfffffffffffffffe,%rsi
jne    1500 <convolution_filter+0x3f0>
testb  $0x1,0x80(%rsp)
01
je     15aa <convolution_filter+0x49a>
lea    (%r10,%rdi,1),%ecx
movups (%r15,%rcx,4),%xmm2
movups 0x10(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
add    0x20(%rsp),%edi
movups (%rbx,%rdi,4),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%rbx,%rdi,4),%xmm2
addps  %xmm3,%xmm2
movups %xmm1,(%rbx,%rdi,4)
movups %xmm2,0x10(%rbx,%rdi,4)
mov    0x90(%rsp),%rax
mov    %rax,%rcx
mov    0x50(%rsp),%r9
cmp    %r9,%rax
mov    %rdx,%rdi
je     1380 <convolution_filter+0x270>
jmp    1432 <convolution_filter+0x322>
xor    %edi,%edi
testb  $0x1,0x80(%rsp)
01
jne    1579 <convolution_filter+0x469>
jmp    15aa <convolution_filter+0x49a>
test   %r8d,%r8d
je     1640 <convolution_filter+0x530>
mov    0x150(%rsp),%r15b
mov    0x148(%rsp),%r12
mov    0x130(%rsp),%r14d
imul   0x8(%rsp),%r14d
add    0x138(%rsp),%r14d
imul   %r8d,%r14d
xor    %ebp,%ebp
jmp    161f <convolution_filter+0x50f>
nopl   0x0(%rax)
movss  %xmm0,(%rbx,%r13,4)
add    $0x1,%rbp
cmp    %rbp,%r9
je     1640 <convolution_filter+0x530>
lea    (%r14,%rbp,1),%r13d
movss  (%r12,%rbp,4),%xmm0
addss  (%rbx,%r13,4),%xmm0
test   %r15b,%r15b
je     1610 <convolution_filter+0x500>
call   1030 <relu@plt>
mov    0x50(%rsp),%r9
jmp    1610 <convolution_filter+0x500>
xor    %eax,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @convolution_filter(float* %0, float* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, float* %10, float* %11, i8 signext %12) {
%14 = alloca float*
%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 float*
%25 = alloca float*
%26 = alloca i8
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca i32
store float* %0, float** %14
store float* %1, float** %15
store i32 %2, i32* %16
store i32 %3, i32* %17
store i32 %4, i32* %18
store i32 %5, i32* %19
store i32 %6, i32* %20
store i32 %7, i32* %21
store i32 %8, i32* %22
store i32 %9, i32* %23
store float* %10, float** %24
store float* %11, float** %25
store i8 %12, i8* %26
store i32 0, i32* %29
br label %37
37: ; preds = %131, %13
%38 = load i32, i32* %29
%39 = load i32, i32* %20
%40 = icmp ult i32 %38, %39
br i1 %40, label %41, label %134
41: ; preds = %37
store i32 0, i32* %30
br label %42
42: ; preds = %127, %41
%43 = load i32, i32* %30
%44 = load i32, i32* %21
%45 = icmp ult i32 %43, %44
br i1 %45, label %46, label %130
46: ; preds = %42
store i32 0, i32* %28
br label %47
47: ; preds = %123, %46
%48 = load i32, i32* %28
%49 = load i32, i32* %16
%50 = icmp ult i32 %48, %49
br i1 %50, label %51, label %126
51: ; preds = %47
%52 = load float*, float** %14
%53 = load i32, i32* %22
%54 = load i32, i32* %29
%55 = add i32 %53, %54
%56 = load i32, i32* %17
%57 = mul i32 %55, %56
%58 = load i32, i32* %16
%59 = mul i32 %57, %58
%60 = load i32, i32* %23
%61 = load i32, i32* %30
%62 = add i32 %60, %61
%63 = load i32, i32* %16
%64 = mul i32 %62, %63
%65 = add i32 %59, %64
%66 = load i32, i32* %28
%67 = add i32 %65, %66
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds float, float* %52, i64 %68
%70 = load float, float* %69
store float %70, float* %33
store i32 0, i32* %27
br label %71
71: ; preds = %119, %51
%72 = load i32, i32* %27
%73 = load i32, i32* %18
%74 = icmp ult i32 %72, %73
br i1 %74, label %75, label %122
75: ; preds = %71
%76 = load float*, float** %24
%77 = load i32, i32* %29
%78 = load i32, i32* %21
%79 = mul i32 %77, %78
%80 = load i32, i32* %16
%81 = mul i32 %79, %80
%82 = load i32, i32* %18
%83 = mul i32 %81, %82
%84 = load i32, i32* %30
%85 = load i32, i32* %16
%86 = mul i32 %84, %85
%87 = load i32, i32* %18
%88 = mul i32 %86, %87
%89 = add i32 %83, %88
%90 = load i32, i32* %28
%91 = load i32, i32* %18
%92 = mul i32 %90, %91
%93 = add i32 %89, %92
%94 = load i32, i32* %27
%95 = add i32 %93, %94
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds float, float* %76, i64 %96
%98 = load float, float* %97
store float %98, float* %31
%99 = load float, float* %33
%100 = load float, float* %31
%101 = fmul float %99, %100
store float %101, float* %34
%102 = load float, float* %34
%103 = load float*, float** %15
%104 = load i32, i32* %22
%105 = load i32, i32* %19
%106 = mul i32 %104, %105
%107 = load i32, i32* %18
%108 = mul i32 %106, %107
%109 = load i32, i32* %23
%110 = load i32, i32* %18
%111 = mul i32 %109, %110
%112 = add i32 %108, %111
%113 = load i32, i32* %27
%114 = add i32 %112, %113
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds float, float* %103, i64 %115
%117 = load float, float* %116
%118 = fadd float %117, %102
store float %118, float* %116
br label %119
119: ; preds = %75
%120 = load i32, i32* %27
%121 = add i32 %120, 1
store i32 %121, i32* %27
br label %71
122: ; preds = %71
br label %123
123: ; preds = %122
%124 = load i32, i32* %28
%125 = add i32 %124, 1
store i32 %125, i32* %28
br label %47
126: ; preds = %47
br label %127
127: ; preds = %126
%128 = load i32, i32* %30
%129 = add i32 %128, 1
store i32 %129, i32* %30
br label %42
130: ; preds = %42
br label %131
131: ; preds = %130
%132 = load i32, i32* %29
%133 = add i32 %132, 1
store i32 %133, i32* %29
br label %37
134: ; preds = %37
store i32 0, i32* %27
br label %135
135: ; preds = %175, %134
%136 = load i32, i32* %27
%137 = load i32, i32* %18
%138 = icmp ult i32 %136, %137
br i1 %138, label %139, label %178
139: ; preds = %135
%140 = load float*, float** %25
%141 = load i32, i32* %27
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds float, float* %140, i64 %142
%144 = load float, float* %143
store float %144, float* %32
%145 = load i32, i32* %22
%146 = load i32, i32* %19
%147 = mul i32 %145, %146
%148 = load i32, i32* %18
%149 = mul i32 %147, %148
%150 = load i32, i32* %23
%151 = load i32, i32* %18
%152 = mul i32 %150, %151
%153 = add i32 %149, %152
%154 = load i32, i32* %27
%155 = add i32 %153, %154
store i32 %155, i32* %36
%156 = load float*, float** %15
%157 = load i32, i32* %36
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds float, float* %156, i64 %158
%160 = load float, float* %159
store float %160, float* %35
%161 = load float, float* %32
%162 = load float, float* %35
%163 = fadd float %162, %161
store float %163, float* %35
%164 = load i8, i8* %26
%165 = icmp ne i8 %164, 0
br i1 %165, label %166, label %169
166: ; preds = %139
%167 = load float, float* %35
%168 = call float @relu(float %167)
store float %168, float* %35
br label %169
169: ; preds = %166, %139
%170 = load float, float* %35
%171 = load float*, float** %15
%172 = load i32, i32* %36
%173 = zext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
store float %170, float* %174
br label %175
175: ; preds = %169
%176 = load i32, i32* %27
%177 = add i32 %176, 1
store i32 %177, i32* %27
br label %135
178: ; preds = %135
ret i32 0
}

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