#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 */
void neuralops_conv2d_bias_fwd(size_t batch_sz, size_t out_width,
                               size_t out_height, size_t out_chan,
                               const float *in_buf, const float *bias,
                               float *out_buf) {
  size_t p = 0;
  for (size_t idx = 0; idx < batch_sz; idx += 1) {
    for (size_t a = 0; a < out_chan; a += 1) {
      float b = bias[a];
      for (size_t y = 0; y < out_height; y += 1) {
        for (size_t x = 0; x < out_width; x += 1) {
          out_buf[p] = in_buf[p] + b;
          p += 1;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<neuralops_conv2d_bias_fwd>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1210 <neuralops_conv2d_bias_fwd+0x110>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11fa <neuralops_conv2d_bias_fwd+0xfa>
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11e4 <neuralops_conv2d_bias_fwd+0xe4>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11ce <neuralops_conv2d_bias_fwd+0xce>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1184 <neuralops_conv2d_bias_fwd+0x84>
jmp    11d3 <neuralops_conv2d_bias_fwd+0xd3>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    116e <neuralops_conv2d_bias_fwd+0x6e>
jmp    11e9 <neuralops_conv2d_bias_fwd+0xe9>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1146 <neuralops_conv2d_bias_fwd+0x46>
jmp    11ff <neuralops_conv2d_bias_fwd+0xff>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1130 <neuralops_conv2d_bias_fwd+0x30>
pop    %rbp
ret

x86 assembly (clang, -O2):
<neuralops_conv2d_bias_fwd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x38(%rsp)
mov    %rcx,-0x48(%rsp)
mov    %rdi,-0x40(%rsp)
test   %rdi,%rdi
je     1354 <neuralops_conv2d_bias_fwd+0x254>
mov    0x38(%rsp),%rax
lea    (%r8,%rsi,4),%rcx
lea    -0x8(%rsi),%rdi
mov    %rdi,-0x8(%rsp)
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
cmp    %rax,%rcx
seta   %cl
lea    (%rax,%rsi,4),%rdi
cmp    %r8,%rdi
seta   %r11b
lea    -0x1(%rsi),%r14
and    %cl,%r11b
mov    %rsi,%r15
and    $0xfffffffffffffff8,%r15
mov    %rbp,%rcx
mov    %rbp,-0x10(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x18(%rsp)
lea    0x30(%rax),%rcx
mov    %rcx,-0x20(%rsp)
lea    0x30(%r8),%rcx
mov    %rcx,-0x28(%rsp)
xor    %r12d,%r12d
xor    %ecx,%ecx
mov    %rcx,-0x50(%rsp)
jmp    11ac <neuralops_conv2d_bias_fwd+0xac>
nopl   (%rax)
mov    -0x50(%rsp),%rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,-0x50(%rsp)
cmp    -0x40(%rsp),%rdi
je     1354 <neuralops_conv2d_bias_fwd+0x254>
cmpq   $0x0,-0x48(%rsp)
je     1190 <neuralops_conv2d_bias_fwd+0x90>
xor    %edi,%edi
jmp    11d0 <neuralops_conv2d_bias_fwd+0xd0>
nopl   0x0(%rax,%rax,1)
mov    -0x30(%rsp),%rdi
add    $0x1,%rdi
cmp    -0x48(%rsp),%rdi
je     1190 <neuralops_conv2d_bias_fwd+0x90>
test   %rdx,%rdx
mov    %rdi,-0x30(%rsp)
je     11c0 <neuralops_conv2d_bias_fwd+0xc0>
mov    -0x38(%rsp),%rcx
movss  (%rcx,%rdi,4),%xmm0
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
xor    %r9d,%r9d
jmp    11fc <neuralops_conv2d_bias_fwd+0xfc>
mov    %r10,%r12
add    $0x1,%r9
cmp    %rdx,%r9
je     11c0 <neuralops_conv2d_bias_fwd+0xc0>
test   %rsi,%rsi
je     11f3 <neuralops_conv2d_bias_fwd+0xf3>
cmp    $0x8,%rsi
setb   %cl
lea    (%r12,%rsi,1),%r10
or     %r11b,%cl
mov    %r12,%r13
jne    12ad <neuralops_conv2d_bias_fwd+0x1ad>
cmpq   $0x8,-0x8(%rsp)
jae    1224 <neuralops_conv2d_bias_fwd+0x124>
xor    %ebp,%ebp
jmp    127c <neuralops_conv2d_bias_fwd+0x17c>
mov    -0x20(%rsp),%rcx
lea    (%rcx,%r12,4),%rdi
mov    -0x28(%rsp),%rcx
lea    (%rcx,%r12,4),%rbx
mov    -0x18(%rsp),%rcx
xor    %ebp,%ebp
nopl   (%rax)
movups -0x30(%rbx,%rbp,4),%xmm2
movups -0x20(%rbx,%rbp,4),%xmm3
addps  %xmm1,%xmm2
addps  %xmm1,%xmm3
movups %xmm2,-0x30(%rdi,%rbp,4)
movups %xmm3,-0x20(%rdi,%rbp,4)
movups -0x10(%rbx,%rbp,4),%xmm2
movups (%rbx,%rbp,4),%xmm3
addps  %xmm1,%xmm2
addps  %xmm1,%xmm3
movups %xmm2,-0x10(%rdi,%rbp,4)
movups %xmm3,(%rdi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1240 <neuralops_conv2d_bias_fwd+0x140>
testb  $0x1,-0x10(%rsp)
je     12a0 <neuralops_conv2d_bias_fwd+0x1a0>
add    %r12,%rbp
movups (%r8,%rbp,4),%xmm2
movups 0x10(%r8,%rbp,4),%xmm3
addps  %xmm1,%xmm2
addps  %xmm1,%xmm3
movups %xmm2,(%rax,%rbp,4)
movups %xmm3,0x10(%rax,%rbp,4)
cmp    %rsi,%r15
je     11f0 <neuralops_conv2d_bias_fwd+0xf0>
lea    (%r12,%r15,1),%r13
lea    (%r12,%rsi,1),%rbp
mov    %ebp,%ecx
sub    %r13d,%ecx
add    %r14,%r12
sub    %r13,%r12
and    $0x3,%rcx
je     12ea <neuralops_conv2d_bias_fwd+0x1ea>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r8,%r13,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rax,%r13,4)
add    $0x1,%r13
add    $0xffffffffffffffff,%rcx
jne    12d0 <neuralops_conv2d_bias_fwd+0x1d0>
cmp    $0x3,%r12
jb     11f0 <neuralops_conv2d_bias_fwd+0xf0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r8,%r13,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rax,%r13,4)
movss  0x4(%r8,%r13,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%rax,%r13,4)
movss  0x8(%r8,%r13,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rax,%r13,4)
movss  0xc(%r8,%r13,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0xc(%rax,%r13,4)
add    $0x4,%r13
cmp    %r13,%rbp
jne    1300 <neuralops_conv2d_bias_fwd+0x200>
jmp    11f0 <neuralops_conv2d_bias_fwd+0xf0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @neuralops_conv2d_bias_fwd(i64 %0, i64 %1, i64 %2, i64 %3, float* %4, float* %5, float* %6) {
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca float
%19 = alloca i64
%20 = alloca i64
store i64 %0, i64* %8
store i64 %1, i64* %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
store i64 0, i64* %15
store i64 0, i64* %16
br label %21
21: ; preds = %68, %7
%22 = load i64, i64* %16
%23 = load i64, i64* %8
%24 = icmp ult i64 %22, %23
br i1 %24, label %25, label %71
25: ; preds = %21
store i64 0, i64* %17
br label %26
26: ; preds = %64, %25
%27 = load i64, i64* %17
%28 = load i64, i64* %11
%29 = icmp ult i64 %27, %28
br i1 %29, label %30, label %67
30: ; preds = %26
%31 = load float*, float** %13
%32 = load i64, i64* %17
%33 = getelementptr inbounds float, float* %31, i64 %32
%34 = load float, float* %33
store float %34, float* %18
store i64 0, i64* %19
br label %35
35: ; preds = %60, %30
%36 = load i64, i64* %19
%37 = load i64, i64* %10
%38 = icmp ult i64 %36, %37
br i1 %38, label %39, label %63
39: ; preds = %35
store i64 0, i64* %20
br label %40
40: ; preds = %56, %39
%41 = load i64, i64* %20
%42 = load i64, i64* %9
%43 = icmp ult i64 %41, %42
br i1 %43, label %44, label %59
44: ; preds = %40
%45 = load float*, float** %12
%46 = load i64, i64* %15
%47 = getelementptr inbounds float, float* %45, i64 %46
%48 = load float, float* %47
%49 = load float, float* %18
%50 = fadd float %48, %49
%51 = load float*, float** %14
%52 = load i64, i64* %15
%53 = getelementptr inbounds float, float* %51, i64 %52
store float %50, float* %53
%54 = load i64, i64* %15
%55 = add i64 %54, 1
store i64 %55, i64* %15
br label %56
56: ; preds = %44
%57 = load i64, i64* %20
%58 = add i64 %57, 1
store i64 %58, i64* %20
br label %40
59: ; preds = %40
br label %60
60: ; preds = %59
%61 = load i64, i64* %19
%62 = add i64 %61, 1
store i64 %62, i64* %19
br label %35
63: ; preds = %35
br label %64
64: ; preds = %63
%65 = load i64, i64* %17
%66 = add i64 %65, 1
store i64 %66, i64* %17
br label %26
67: ; preds = %26
br label %68
68: ; preds = %67
%69 = load i64, i64* %16
%70 = add i64 %69, 1
store i64 %70, i64* %16
br label %21
71: ; preds = %21
ret void
}

LLVM IR (-O2):
define void @neuralops_conv2d_bias_fwd(i64 %0, i64 %1, i64 %2, i64 %3, float* nocapture %4, float* nocapture %5, float* nocapture writeonly %6) {
%8 = icmp eq i64 %0, 0
br i1 %8, label %32, label %9
9: ; preds = %7
%10 = icmp eq i64 %3, 0
%11 = icmp eq i64 %2, 0
%12 = icmp eq i64 %1, 0
%13 = getelementptr float, float* %6, i64 %1
%14 = getelementptr float, float* %4, i64 %1
%15 = add i64 %1, -8
%16 = lshr i64 %15, 3
%17 = add nuw nsw i64 %16, 1
%18 = add i64 %1, -1
%19 = icmp ult i64 %1, 8
%20 = icmp ugt float* %14, %6
%21 = icmp ugt float* %13, %4
%22 = and i1 %20, %21
%23 = and i64 %1, -8
%24 = and i64 %17, 1
%25 = icmp ult i64 %15, 8
%26 = and i64 %17, 4611686018427387902
%27 = icmp eq i64 %24, 0
%28 = icmp eq i64 %23, %1
br label %29
29: ; preds = %9, %33
%30 = phi i64 [ 0, %9 ], [ %34, %33 ]
%31 = phi i64 [ 0, %9 ], [ %35, %33 ]
br i1 %10, label %33, label %37
32: ; preds = %33, %7
ret void
33: ; preds = %126, %29
%34 = phi i64 [ %30, %29 ], [ %127, %126 ]
%35 = add nuw i64 %31, 1
%36 = icmp eq i64 %35, %0
br i1 %36, label %32, label %29
37: ; preds = %29, %126
%38 = phi i64 [ %127, %126 ], [ %30, %29 ]
%39 = phi i64 [ %128, %126 ], [ 0, %29 ]
%40 = getelementptr inbounds float, float* %5, i64 %39
%41 = load float, float* %40
br i1 %11, label %126, label %42
42: ; preds = %37
%43 = insertelement <4 x float> poison, float %41, i64 0
%44 = shufflevector <4 x float> %43, <4 x float> poison, <4 x i32> zeroinitializer
%45 = insertelement <4 x float> poison, float %41, i64 0
%46 = shufflevector <4 x float> %45, <4 x float> poison, <4 x i32> zeroinitializer
br label %47
47: ; preds = %42, %130
%48 = phi i64 [ %132, %130 ], [ 0, %42 ]
%49 = phi i64 [ %131, %130 ], [ %38, %42 ]
br i1 %12, label %130, label %50
50: ; preds = %47
%51 = add i64 %49, %1
%52 = or i1 %19, %22
br i1 %52, label %105, label %53
53: ; preds = %50
%54 = add i64 %49, %23
br i1 %25, label %88, label %55
55: ; preds = %53, %55
%56 = phi i64 [ %85, %55 ], [ 0, %53 ]
%57 = phi i64 [ %86, %55 ], [ 0, %53 ]
%58 = add i64 %49, %56
%59 = getelementptr inbounds float, float* %4, i64 %58
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = getelementptr inbounds float, float* %59, i64 4
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = fadd <4 x float> %44, %61
%66 = fadd <4 x float> %46, %64
%67 = getelementptr inbounds float, float* %6, i64 %58
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %65, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %66, <4 x float>* %70
%71 = or i64 %56, 8
%72 = add i64 %49, %71
%73 = getelementptr inbounds float, float* %4, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %73, i64 4
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = fadd <4 x float> %44, %75
%80 = fadd <4 x float> %46, %78
%81 = getelementptr inbounds float, float* %6, i64 %72
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %79, <4 x float>* %82
%83 = getelementptr inbounds float, float* %81, i64 4
%84 = bitcast float* %83 to <4 x float>*
store <4 x float> %80, <4 x float>* %84
%85 = add nuw i64 %56, 16
%86 = add i64 %57, 2
%87 = icmp eq i64 %86, %26
br i1 %87, label %88, label %55
88: ; preds = %55, %53
%89 = phi i64 [ 0, %53 ], [ %85, %55 ]
br i1 %27, label %104, label %90
90: ; preds = %88
%91 = add i64 %49, %89
%92 = getelementptr inbounds float, float* %4, 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 = fadd <4 x float> %44, %94
%99 = fadd <4 x float> %46, %97
%100 = getelementptr inbounds float, float* %6, i64 %91
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %98, <4 x float>* %101
%102 = getelementptr inbounds float, float* %100, i64 4
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> %99, <4 x float>* %103
br label %104
104: ; preds = %88, %90
br i1 %28, label %130, label %105
105: ; preds = %50, %104
%106 = phi i64 [ %49, %50 ], [ %54, %104 ]
%107 = add i64 %49, %1
%108 = sub i64 %107, %106
%109 = add i64 %18, %49
%110 = sub i64 %109, %106
%111 = and i64 %108, 3
%112 = icmp eq i64 %111, 0
br i1 %112, label %123, label %113
113: ; preds = %105, %113
%114 = phi i64 [ %120, %113 ], [ %106, %105 ]
%115 = phi i64 [ %121, %113 ], [ 0, %105 ]
%116 = getelementptr inbounds float, float* %4, i64 %114
%117 = load float, float* %116
%118 = fadd float %41, %117
%119 = getelementptr inbounds float, float* %6, i64 %114
store float %118, float* %119
%120 = add i64 %114, 1
%121 = add i64 %115, 1
%122 = icmp eq i64 %121, %111
br i1 %122, label %123, label %113
123: ; preds = %113, %105
%124 = phi i64 [ %106, %105 ], [ %120, %113 ]
%125 = icmp ult i64 %110, 3
br i1 %125, label %130, label %134
126: ; preds = %130, %37
%127 = phi i64 [ %38, %37 ], [ %131, %130 ]
%128 = add nuw i64 %39, 1
%129 = icmp eq i64 %128, %3
br i1 %129, label %33, label %37
130: ; preds = %123, %134, %104, %47
%131 = phi i64 [ %49, %47 ], [ %51, %104 ], [ %51, %134 ], [ %51, %123 ]
%132 = add nuw i64 %48, 1
%133 = icmp eq i64 %132, %2
br i1 %133, label %126, label %47
134: ; preds = %123, %134
%135 = phi i64 [ %155, %134 ], [ %124, %123 ]
%136 = getelementptr inbounds float, float* %4, i64 %135
%137 = load float, float* %136
%138 = fadd float %41, %137
%139 = getelementptr inbounds float, float* %6, i64 %135
store float %138, float* %139
%140 = add i64 %135, 1
%141 = getelementptr inbounds float, float* %4, i64 %140
%142 = load float, float* %141
%143 = fadd float %41, %142
%144 = getelementptr inbounds float, float* %6, i64 %140
store float %143, float* %144
%145 = add i64 %135, 2
%146 = getelementptr inbounds float, float* %4, i64 %145
%147 = load float, float* %146
%148 = fadd float %41, %147
%149 = getelementptr inbounds float, float* %6, i64 %145
store float %148, float* %149
%150 = add i64 %135, 3
%151 = getelementptr inbounds float, float* %4, i64 %150
%152 = load float, float* %151
%153 = fadd float %41, %152
%154 = getelementptr inbounds float, float* %6, i64 %150
store float %153, float* %154
%155 = add i64 %135, 4
%156 = icmp eq i64 %155, %51
br i1 %156, label %130, label %134
}