#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 uint32_t;

/* Variables and functions */
void nnp_conv1x1_upto_2x4__scalar(uint32_t input_channels_subblock_size,
                                  uint32_t output_channels_subblock_size,
                                  size_t input_channels, size_t image_size,
                                  const float *input, const float *kernel,
                                  float *output) {
  const float *pinput0 = input;
  const float *pinput1 = input + image_size;
  float kernel00, kernel01, kernel10, kernel11, kernel20, kernel21, kernel30,
      kernel31;
  kernel00 = kernel[0];
  if (input_channels_subblock_size > 1) {
    kernel01 = kernel[1];
  }
  if (output_channels_subblock_size > 1) {
    kernel += input_channels;
    kernel10 = kernel[0];
    if (input_channels_subblock_size > 1) {
      kernel11 = kernel[1];
    }
    if (output_channels_subblock_size > 2) {
      kernel += input_channels;
      kernel20 = kernel[0];
      if (input_channels_subblock_size > 1) {
        kernel21 = kernel[1];
      }
      if (output_channels_subblock_size > 3) {
        kernel += input_channels;
        kernel30 = kernel[0];
        if (input_channels_subblock_size > 1) {
          kernel31 = kernel[1];
        }
      }
    }
  }
  float *poutput0 = output;
  float *poutput1 = poutput0 + image_size;
  float *poutput2 = poutput1 + image_size;
  float *poutput3 = poutput2 + image_size;
  do {
    float output0, output1, output2, output3;
    output0 = *poutput0;
    if (output_channels_subblock_size > 1) {
      output1 = *poutput1;
      if (output_channels_subblock_size > 2) {
        output2 = *poutput2;
        if (output_channels_subblock_size > 3) {
          output3 = *poutput3;
        }
      }
    }
    const float input0 = *pinput0++;
    output0 += kernel00 * input0;
    output1 += kernel10 * input0;
    output2 += kernel20 * input0;
    output3 += kernel30 * input0;
    if (input_channels_subblock_size > 1) {
      const float input1 = *pinput1++;
      output0 += kernel01 * input1;
      output1 += kernel11 * input1;
      output2 += kernel21 * input1;
      output3 += kernel31 * input1;
    }
    *poutput0++ = output0;
    if (output_channels_subblock_size > 1) {
      *poutput1++ = output1;
      if (output_channels_subblock_size > 2) {
        *poutput2++ = output2;
        if (output_channels_subblock_size > 3) {
          *poutput3++ = output3;
        }
      }
    }
  } while (--image_size != 0);
}


x86 assembly (clang, -O0):
<nnp_conv1x1_upto_2x4__scalar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
cmpl   $0x1,-0x4(%rbp)
jle    1162 <nnp_conv1x1_upto_2x4__scalar+0x62>
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
cmpl   $0x1,-0x8(%rbp)
jle    122e <nnp_conv1x1_upto_2x4__scalar+0x12e>
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
cmpl   $0x1,-0x4(%rbp)
jle    11a1 <nnp_conv1x1_upto_2x4__scalar+0xa1>
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
cmpl   $0x2,-0x8(%rbp)
jle    1229 <nnp_conv1x1_upto_2x4__scalar+0x129>
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x1,-0x4(%rbp)
jle    11e0 <nnp_conv1x1_upto_2x4__scalar+0xe0>
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
cmpl   $0x3,-0x8(%rbp)
jle    1224 <nnp_conv1x1_upto_2x4__scalar+0x124>
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
cmpl   $0x1,-0x4(%rbp)
jle    121f <nnp_conv1x1_upto_2x4__scalar+0x11f>
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1224 <nnp_conv1x1_upto_2x4__scalar+0x124>
jmp    1229 <nnp_conv1x1_upto_2x4__scalar+0x129>
jmp    122e <nnp_conv1x1_upto_2x4__scalar+0x12e>
mov    0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
cmpl   $0x1,-0x8(%rbp)
jle    12d1 <nnp_conv1x1_upto_2x4__scalar+0x1d1>
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
cmpl   $0x2,-0x8(%rbp)
jle    12cc <nnp_conv1x1_upto_2x4__scalar+0x1cc>
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
cmpl   $0x3,-0x8(%rbp)
jle    12c7 <nnp_conv1x1_upto_2x4__scalar+0x1c7>
mov    -0x78(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    12cc <nnp_conv1x1_upto_2x4__scalar+0x1cc>
jmp    12d1 <nnp_conv1x1_upto_2x4__scalar+0x1d1>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x4(%rbp)
jle    1421 <nnp_conv1x1_upto_2x4__scalar+0x321>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  %xmm0,(%rax)
cmpl   $0x1,-0x8(%rbp)
jle    14af <nnp_conv1x1_upto_2x4__scalar+0x3af>
movss  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  %xmm0,(%rax)
cmpl   $0x2,-0x8(%rbp)
jle    14aa <nnp_conv1x1_upto_2x4__scalar+0x3aa>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  %xmm0,(%rax)
cmpl   $0x3,-0x8(%rbp)
jle    14a5 <nnp_conv1x1_upto_2x4__scalar+0x3a5>
movss  -0x88(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
jmp    14aa <nnp_conv1x1_upto_2x4__scalar+0x3aa>
jmp    14af <nnp_conv1x1_upto_2x4__scalar+0x3af>
jmp    14b4 <nnp_conv1x1_upto_2x4__scalar+0x3b4>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    126f <nnp_conv1x1_upto_2x4__scalar+0x16f>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nnp_conv1x1_upto_2x4__scalar>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x28(%rsp),%r10
movss  (%r9),%xmm0
cmp    $0x2,%edi
jl     113f <nnp_conv1x1_upto_2x4__scalar+0x3f>
movss  0x4(%r9),%xmm1
cmp    $0x1,%esi
jle    1168 <nnp_conv1x1_upto_2x4__scalar+0x68>
movss  (%r9,%rdx,4),%xmm2
movss  0x4(%r9,%rdx,4),%xmm5
movlhps %xmm1,%xmm5
shufps $0xe2,%xmm1,%xmm5
mov    $0x1,%r11b
cmp    $0x2,%esi
jne    1172 <nnp_conv1x1_upto_2x4__scalar+0x72>
jmp    11a7 <nnp_conv1x1_upto_2x4__scalar+0xa7>
cmp    $0x2,%esi
jl     116d <nnp_conv1x1_upto_2x4__scalar+0x6d>
movss  (%r9,%rdx,4),%xmm2
mov    $0x1,%r11b
je     1170 <nnp_conv1x1_upto_2x4__scalar+0x70>
lea    (%r9,%rdx,4),%rax
movss  (%rax,%rdx,4),%xmm3
cmp    $0x4,%esi
jb     1170 <nnp_conv1x1_upto_2x4__scalar+0x70>
lea    (%rax,%rdx,4),%rax
movss  (%rax,%rdx,4),%xmm4
jmp    1170 <nnp_conv1x1_upto_2x4__scalar+0x70>
xor    %r11d,%r11d
jmp    11aa <nnp_conv1x1_upto_2x4__scalar+0xaa>
xor    %r11d,%r11d
jmp    11aa <nnp_conv1x1_upto_2x4__scalar+0xaa>
lea    (%r9,%rdx,4),%rax
movss  (%rax,%rdx,4),%xmm3
movss  0x4(%rax,%rdx,4),%xmm1
shufps $0x30,%xmm5,%xmm1
shufps $0x84,%xmm1,%xmm5
cmp    $0x3,%esi
jbe    11a7 <nnp_conv1x1_upto_2x4__scalar+0xa7>
lea    (%rax,%rdx,4),%rax
movss  (%rax,%rdx,4),%xmm4
movss  0x4(%rax,%rdx,4),%xmm1
shufps $0xe4,%xmm5,%xmm1
shufps $0x24,%xmm1,%xmm5
jmp    11a7 <nnp_conv1x1_upto_2x4__scalar+0xa7>
movaps %xmm5,%xmm1
unpcklps %xmm2,%xmm0
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm0
lea    (%r8,%rcx,4),%r14
lea    (%r10,%rcx,4),%rdx
lea    (%rdx,%rcx,4),%rbx
lea    (%rbx,%rcx,4),%r9
xor    %eax,%eax
jmp    11ec <nnp_conv1x1_upto_2x4__scalar+0xec>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%r15
mov    %rbx,%r12
movhlps %xmm2,%xmm2
add    $0x1,%rax
mov    %r15,%rdx
mov    %r12,%rbx
cmp    %rax,%rcx
je     12a8 <nnp_conv1x1_upto_2x4__scalar+0x1a8>
test   %r11b,%r11b
je     1220 <nnp_conv1x1_upto_2x4__scalar+0x120>
movss  (%rdx),%xmm3
cmp    $0x2,%esi
je     1220 <nnp_conv1x1_upto_2x4__scalar+0x120>
movss  (%rbx),%xmm4
cmp    $0x4,%esi
jl     1210 <nnp_conv1x1_upto_2x4__scalar+0x110>
movss  (%r9),%xmm2
unpcklps %xmm2,%xmm4
movaps %xmm4,%xmm2
jmp    1220 <nnp_conv1x1_upto_2x4__scalar+0x120>
movss  %xmm4,%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r10,%rax,4),%xmm4
unpcklps %xmm3,%xmm4
movlhps %xmm2,%xmm4
movss  (%r8,%rax,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
cmp    $0x2,%edi
jl     1254 <nnp_conv1x1_upto_2x4__scalar+0x154>
movss  (%r14),%xmm3
add    $0x4,%r14
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
addps  %xmm3,%xmm2
movss  %xmm2,(%r10,%rax,4)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
test   %r11b,%r11b
je     11d0 <nnp_conv1x1_upto_2x4__scalar+0xd0>
lea    0x4(%rdx),%r15
movss  %xmm3,(%rdx)
cmp    $0x2,%esi
je     11d3 <nnp_conv1x1_upto_2x4__scalar+0xd3>
lea    0x4(%rbx),%r12
movaps %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
movss  %xmm4,(%rbx)
cmp    $0x4,%esi
jl     11d6 <nnp_conv1x1_upto_2x4__scalar+0xd6>
movaps %xmm2,%xmm4
shufps $0xff,%xmm2,%xmm4
movss  %xmm4,(%r9)
add    $0x4,%r9
jmp    11d6 <nnp_conv1x1_upto_2x4__scalar+0xd6>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @nnp_conv1x1_upto_2x4__scalar(i32 %0, i32 %1, i64 %2, i64 %3, float* nocapture %4, float* nocapture %5, float* nocapture %6) {
%8 = getelementptr inbounds float, float* %4, i64 %3
%9 = load float, float* %5
%10 = icmp sgt i32 %0, 1
br i1 %10, label %11, label %16
11: ; preds = %7
%12 = getelementptr inbounds float, float* %5, i64 1
%13 = load float, float* %12
%14 = icmp sgt i32 %1, 1
%15 = insertelement <4 x float> poison, float %13, i64 0
br i1 %14, label %22, label %49
16: ; preds = %7
%17 = icmp sgt i32 %1, 1
br i1 %17, label %18, label %49
18: ; preds = %16
%19 = getelementptr inbounds float, float* %5, i64 %2
%20 = load float, float* %19
%21 = icmp eq i32 %1, 2
br i1 %21, label %49, label %36
22: ; preds = %11
%23 = getelementptr inbounds float, float* %5, i64 %2
%24 = load float, float* %23
%25 = getelementptr inbounds float, float* %23, i64 1
%26 = load float, float* %25
%27 = icmp eq i32 %1, 2
%28 = insertelement <4 x float> %15, float %26, i64 1
br i1 %27, label %49, label %29
29: ; preds = %22
%30 = getelementptr inbounds float, float* %23, i64 %2
%31 = load float, float* %30
%32 = getelementptr inbounds float, float* %30, i64 1
%33 = load float, float* %32
%34 = icmp ugt i32 %1, 3
%35 = insertelement <4 x float> %28, float %33, i64 2
br i1 %34, label %43, label %49
36: ; preds = %18
%37 = getelementptr inbounds float, float* %19, i64 %2
%38 = load float, float* %37
%39 = icmp ugt i32 %1, 3
br i1 %39, label %40, label %49
40: ; preds = %36
%41 = getelementptr inbounds float, float* %37, i64 %2
%42 = load float, float* %41
br label %49
43: ; preds = %29
%44 = getelementptr inbounds float, float* %30, i64 %2
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %44, i64 1
%47 = load float, float* %46
%48 = insertelement <4 x float> %35, float %47, i64 3
br label %49
49: ; preds = %40, %36, %22, %16, %18, %43, %29, %11
%50 = phi i1 [ true, %43 ], [ true, %29 ], [ true, %18 ], [ false, %11 ], [ false, %16 ], [ true, %22 ], [ true, %36 ], [ true, %40 ]
%51 = phi float [ %24, %43 ], [ %24, %29 ], [ %20, %18 ], [ undef, %11 ], [ undef, %16 ], [ %24, %22 ], [ %20, %36 ], [ %20, %40 ]
%52 = phi float [ %31, %43 ], [ %31, %29 ], [ undef, %18 ], [ undef, %11 ], [ undef, %16 ], [ undef, %22 ], [ %38, %36 ], [ %38, %40 ]
%53 = phi float [ %45, %43 ], [ undef, %29 ], [ undef, %18 ], [ undef, %11 ], [ undef, %16 ], [ undef, %22 ], [ undef, %36 ], [ %42, %40 ]
%54 = phi <4 x float> [ %48, %43 ], [ %35, %29 ], [ poison, %18 ], [ %15, %11 ], [ poison, %16 ], [ %28, %22 ], [ poison, %36 ], [ poison, %40 ]
%55 = getelementptr inbounds float, float* %6, i64 %3
%56 = getelementptr inbounds float, float* %55, i64 %3
%57 = getelementptr inbounds float, float* %56, i64 %3
%58 = icmp eq i32 %1, 2
%59 = icmp sgt i32 %1, 3
%60 = insertelement <4 x float> poison, float %9, i64 0
%61 = insertelement <4 x float> %60, float %51, i64 1
%62 = insertelement <4 x float> %61, float %52, i64 2
%63 = insertelement <4 x float> %62, float %53, i64 3
br label %64
64: ; preds = %116, %49
%65 = phi float* [ %8, %49 ], [ %103, %116 ]
%66 = phi float* [ %4, %49 ], [ %87, %116 ]
%67 = phi float* [ %6, %49 ], [ %105, %116 ]
%68 = phi float* [ %55, %49 ], [ %117, %116 ]
%69 = phi float* [ %56, %49 ], [ %118, %116 ]
%70 = phi float* [ %57, %49 ], [ %119, %116 ]
%71 = phi float [ undef, %49 ], [ %122, %116 ]
%72 = phi i64 [ %3, %49 ], [ %120, %116 ]
%73 = phi <2 x float> [ undef, %49 ], [ %123, %116 ]
%74 = load float, float* %67
br i1 %50, label %75, label %84
75: ; preds = %64
%76 = load float, float* %68
br i1 %58, label %84, label %77
77: ; preds = %75
%78 = load float, float* %69
%79 = insertelement <2 x float> %73, float %78, i64 0
br i1 %59, label %80, label %84
80: ; preds = %77
%81 = insertelement <2 x float> poison, float %78, i64 0
%82 = load float, float* %70
%83 = insertelement <2 x float> %81, float %82, i64 1
br label %84
84: ; preds = %75, %80, %77, %64
%85 = phi float [ %76, %80 ], [ %76, %77 ], [ %76, %75 ], [ %71, %64 ]
%86 = phi <2 x float> [ %83, %80 ], [ %79, %77 ], [ %73, %75 ], [ %73, %64 ]
%87 = getelementptr inbounds float, float* %66, i64 1
%88 = load float, float* %66
%89 = insertelement <4 x float> poison, float %88, i64 0
%90 = shufflevector <4 x float> %89, <4 x float> poison, <4 x i32> zeroinitializer
%91 = insertelement <4 x float> poison, float %74, i64 0
%92 = insertelement <4 x float> %91, float %85, i64 1
%93 = shufflevector <2 x float> %86, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%94 = shufflevector <4 x float> %92, <4 x float> %93, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%95 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %63, <4 x float> %90, <4 x float> %94)
br i1 %10, label %96, label %102
96: ; preds = %84
%97 = getelementptr inbounds float, float* %65, i64 1
%98 = load float, float* %65
%99 = insertelement <4 x float> poison, float %98, i64 0
%100 = shufflevector <4 x float> %99, <4 x float> poison, <4 x i32> zeroinitializer
%101 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %54, <4 x float> %100, <4 x float> %95)
br label %102
102: ; preds = %96, %84
%103 = phi float* [ %97, %96 ], [ %65, %84 ]
%104 = phi <4 x float> [ %101, %96 ], [ %95, %84 ]
%105 = getelementptr inbounds float, float* %67, i64 1
%106 = extractelement <4 x float> %104, i64 0
store float %106, float* %67
br i1 %50, label %107, label %116
107: ; preds = %102
%108 = getelementptr inbounds float, float* %68, i64 1
%109 = extractelement <4 x float> %104, i64 1
store float %109, float* %68
br i1 %58, label %116, label %110
110: ; preds = %107
%111 = getelementptr inbounds float, float* %69, i64 1
%112 = extractelement <4 x float> %104, i64 2
store float %112, float* %69
br i1 %59, label %113, label %116
113: ; preds = %110
%114 = getelementptr inbounds float, float* %70, i64 1
%115 = extractelement <4 x float> %104, i64 3
store float %115, float* %70
br label %116
116: ; preds = %107, %113, %110, %102
%117 = phi float* [ %108, %113 ], [ %108, %110 ], [ %108, %107 ], [ %68, %102 ]
%118 = phi float* [ %111, %113 ], [ %111, %110 ], [ %69, %107 ], [ %69, %102 ]
%119 = phi float* [ %114, %113 ], [ %70, %110 ], [ %70, %107 ], [ %70, %102 ]
%120 = add i64 %72, -1
%121 = icmp eq i64 %120, 0
%122 = extractelement <4 x float> %104, i64 1
%123 = shufflevector <4 x float> %104, <4 x float> undef, <2 x i32> <i32 2, i32 3>
br i1 %121, label %124, label %64
124: ; preds = %116
ret void
}