diff --git a/src/layer/arm/gemm_arm.cpp b/src/layer/arm/gemm_arm.cpp
index c1e0c3e0d69..b209f24b9c2 100644
--- a/src/layer/arm/gemm_arm.cpp
+++ b/src/layer/arm/gemm_arm.cpp
@@ -6160,21 +6160,6 @@ int Gemm_arm::forward_int8(const std::vector<Mat>& bottom_blobs, std::vector<Mat
                 // 1xN
                 broadcast_type_C = 4;
             }
-
-            // pre-multiply C with beta
-            if (beta != 1.f)
-            {
-                Mat CT_data;
-                CT_data.create_like(C, opt.workspace_allocator);
-
-                const int size = C.total() * C.elempack;
-                for (int i = 0; i < size; i++)
-                {
-                    CT_data[i] = C[i] * beta;
-                }
-
-                C = CT_data;
-            }
         }
     }
 
@@ -6242,22 +6227,8 @@ int Gemm_arm::forward_int8(const std::vector<Mat>& bottom_blobs, std::vector<Mat
         const Mat& B = bottom_blobs[1];
         ret = gemm_arm_int8(A, B, C, top_blob, broadcast_type_C, transA, transB, output_transpose, constant_TILE_M, constant_TILE_N, constant_TILE_K, _nT, opt);
     }
-    if (ret != 0)
-        return ret;
-
-    // multiply top_blob with alpha
-    if (alpha != 1.f)
-    {
-        const int size = top_blob.total() * out_elempack;
 
-        #pragma omp parallel for num_threads(opt.num_threads)
-        for (int i = 0; i < size; i++)
-        {
-            top_blob[i] *= alpha;
-        }
-    }
-
-    return 0;
+    return ret;
 }
 #endif
 
diff --git a/src/layer/arm/gemm_int8.h b/src/layer/arm/gemm_int8.h
index 12d6d51b7ef..e66aca7668e 100644
--- a/src/layer/arm/gemm_int8.h
+++ b/src/layer/arm/gemm_int8.h
@@ -5583,7 +5583,7 @@ static void transpose_pack_B_tile_fp32_to_int8(const Mat& B, Mat& BT, int j, int
     }
 }
 
-static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat& top_blob, int broadcast_type_C, int i, int max_ii, int j, int max_jj, const Mat& descales)
+static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat& top_blob, int broadcast_type_C, int i, int max_ii, int j, int max_jj, const Mat& descales, float alpha = 1.f, float beta = 1.f)
 {
 #if NCNN_RUNTIME_CPU && NCNN_ARM82DOT && __aarch64__ && !__ARM_FEATURE_DOTPROD && !__ARM_FEATURE_MATMUL_INT8
     if (ncnn::cpu_support_arm_asimddp())
@@ -5619,13 +5619,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
         {
             if (broadcast_type_C == 0)
             {
-                _c0 = vdupq_n_f32(pC[0]);
+                _c0 = vdupq_n_f32(pC[0] * beta);
             }
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
                 _c0 = vld1q_f32(pC);
                 _c1 = vld1q_f32(pC + 4);
+                _c0 = vmulq_n_f32(_c0, beta);
+                _c1 = vmulq_n_f32(_c1, beta);
             }
             if (broadcast_type_C == 3)
             {
@@ -5870,35 +5872,65 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c5 = vld1q_f32(pC + c_hstep * 2 + 4);
                             float32x4_t _c6 = vld1q_f32(pC + c_hstep * 3);
                             float32x4_t _c7 = vld1q_f32(pC + c_hstep * 3 + 4);
-                            float32x4_t _c8 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c9 = vld1q_f32(pC + c_hstep * 4 + 4);
-                            float32x4_t _ca = vld1q_f32(pC + c_hstep * 5);
-                            float32x4_t _cb = vld1q_f32(pC + c_hstep * 5 + 4);
-                            float32x4_t _cc = vld1q_f32(pC + c_hstep * 6);
-                            float32x4_t _cd = vld1q_f32(pC + c_hstep * 6 + 4);
-                            float32x4_t _ce = vld1q_f32(pC + c_hstep * 7);
-                            float32x4_t _cf = vld1q_f32(pC + c_hstep * 7 + 4);
                             transpose8x4_ps(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7);
-                            transpose8x4_ps(_c8, _c9, _ca, _cb, _cc, _cd, _ce, _cf);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
-                            _f8 = vaddq_f32(_f8, _c8);
-                            _f9 = vaddq_f32(_f9, _c9);
-                            _fa = vaddq_f32(_fa, _ca);
-                            _fb = vaddq_f32(_fb, _cb);
-                            _fc = vaddq_f32(_fc, _cc);
-                            _fd = vaddq_f32(_fd, _cd);
-                            _fe = vaddq_f32(_fe, _ce);
-                            _ff = vaddq_f32(_ff, _cf);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                                _f4 = vaddq_f32(_f4, _c4);
+                                _f5 = vaddq_f32(_f5, _c5);
+                                _f6 = vaddq_f32(_f6, _c6);
+                                _f7 = vaddq_f32(_f7, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                                _f4 = vmlaq_f32(_f4, _c4, _beta);
+                                _f5 = vmlaq_f32(_f5, _c5, _beta);
+                                _f6 = vmlaq_f32(_f6, _c6, _beta);
+                                _f7 = vmlaq_f32(_f7, _c7, _beta);
+                            }
+                            _c0 = vld1q_f32(pC + c_hstep * 4);
+                            _c1 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            _c2 = vld1q_f32(pC + c_hstep * 5);
+                            _c3 = vld1q_f32(pC + c_hstep * 5 + 4);
+                            _c4 = vld1q_f32(pC + c_hstep * 6);
+                            _c5 = vld1q_f32(pC + c_hstep * 6 + 4);
+                            _c6 = vld1q_f32(pC + c_hstep * 7);
+                            _c7 = vld1q_f32(pC + c_hstep * 7 + 4);
+                            transpose8x4_ps(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7);
+                            if (beta == 1.f)
+                            {
+                                _f8 = vaddq_f32(_f8, _c0);
+                                _f9 = vaddq_f32(_f9, _c1);
+                                _fa = vaddq_f32(_fa, _c2);
+                                _fb = vaddq_f32(_fb, _c3);
+                                _fc = vaddq_f32(_fc, _c4);
+                                _fd = vaddq_f32(_fd, _c5);
+                                _fe = vaddq_f32(_fe, _c6);
+                                _ff = vaddq_f32(_ff, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f8 = vmlaq_f32(_f8, _c0, _beta);
+                                _f9 = vmlaq_f32(_f9, _c1, _beta);
+                                _fa = vmlaq_f32(_fa, _c2, _beta);
+                                _fb = vmlaq_f32(_fb, _c3, _beta);
+                                _fc = vmlaq_f32(_fc, _c4, _beta);
+                                _fd = vmlaq_f32(_fd, _c5, _beta);
+                                _fe = vmlaq_f32(_fe, _c6, _beta);
+                                _ff = vmlaq_f32(_ff, _c7, _beta);
+                            }
                             pC += 8;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + 4);
@@ -5908,43 +5940,92 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c5 = vld1q_f32(pC + 4 * 5);
                             float32x4_t _c6 = vld1q_f32(pC + 4 * 6);
                             float32x4_t _c7 = vld1q_f32(pC + 4 * 7);
-                            float32x4_t _c8 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c9 = vld1q_f32(pC + c_hstep * 4 + 4);
-                            float32x4_t _ca = vld1q_f32(pC + c_hstep * 4 + 4 * 2);
-                            float32x4_t _cb = vld1q_f32(pC + c_hstep * 4 + 4 * 3);
-                            float32x4_t _cc = vld1q_f32(pC + c_hstep * 4 + 4 * 4);
-                            float32x4_t _cd = vld1q_f32(pC + c_hstep * 4 + 4 * 5);
-                            float32x4_t _ce = vld1q_f32(pC + c_hstep * 4 + 4 * 6);
-                            float32x4_t _cf = vld1q_f32(pC + c_hstep * 4 + 4 * 7);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
-                            _f8 = vaddq_f32(_f8, _c8);
-                            _f9 = vaddq_f32(_f9, _c9);
-                            _fa = vaddq_f32(_fa, _ca);
-                            _fb = vaddq_f32(_fb, _cb);
-                            _fc = vaddq_f32(_fc, _cc);
-                            _fd = vaddq_f32(_fd, _cd);
-                            _fe = vaddq_f32(_fe, _ce);
-                            _ff = vaddq_f32(_ff, _cf);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                                _f4 = vaddq_f32(_f4, _c4);
+                                _f5 = vaddq_f32(_f5, _c5);
+                                _f6 = vaddq_f32(_f6, _c6);
+                                _f7 = vaddq_f32(_f7, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                                _f4 = vmlaq_f32(_f4, _c4, _beta);
+                                _f5 = vmlaq_f32(_f5, _c5, _beta);
+                                _f6 = vmlaq_f32(_f6, _c6, _beta);
+                                _f7 = vmlaq_f32(_f7, _c7, _beta);
+                            }
+                            _c0 = vld1q_f32(pC + c_hstep * 4);
+                            _c1 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            _c2 = vld1q_f32(pC + c_hstep * 4 + 4 * 2);
+                            _c3 = vld1q_f32(pC + c_hstep * 4 + 4 * 3);
+                            _c4 = vld1q_f32(pC + c_hstep * 4 + 4 * 4);
+                            _c5 = vld1q_f32(pC + c_hstep * 4 + 4 * 5);
+                            _c6 = vld1q_f32(pC + c_hstep * 4 + 4 * 6);
+                            _c7 = vld1q_f32(pC + c_hstep * 4 + 4 * 7);
+                            if (beta == 1.f)
+                            {
+                                _f8 = vaddq_f32(_f8, _c0);
+                                _f9 = vaddq_f32(_f9, _c1);
+                                _fa = vaddq_f32(_fa, _c2);
+                                _fb = vaddq_f32(_fb, _c3);
+                                _fc = vaddq_f32(_fc, _c4);
+                                _fd = vaddq_f32(_fd, _c5);
+                                _fe = vaddq_f32(_fe, _c6);
+                                _ff = vaddq_f32(_ff, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f8 = vmlaq_f32(_f8, _c0, _beta);
+                                _f9 = vmlaq_f32(_f9, _c1, _beta);
+                                _fa = vmlaq_f32(_fa, _c2, _beta);
+                                _fb = vmlaq_f32(_fb, _c3, _beta);
+                                _fc = vmlaq_f32(_fc, _c4, _beta);
+                                _fd = vmlaq_f32(_fd, _c5, _beta);
+                                _fe = vmlaq_f32(_fe, _c6, _beta);
+                                _ff = vmlaq_f32(_ff, _c7, _beta);
+                            }
                             pC += 32;
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        _c1 = vdupq_n_f32(pC[1]);
-                        float32x4_t _c2 = vdupq_n_f32(pC[2]);
-                        float32x4_t _c3 = vdupq_n_f32(pC[3]);
-                        float32x4_t _c4 = vdupq_n_f32(pC[4]);
-                        float32x4_t _c5 = vdupq_n_f32(pC[5]);
-                        float32x4_t _c6 = vdupq_n_f32(pC[6]);
-                        float32x4_t _c7 = vdupq_n_f32(pC[7]);
+                        float32x4_t _cc0 = vld1q_f32(pC);
+                        float32x4_t _cc1 = vld1q_f32(pC + 4);
+                        if (beta != 1.f)
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _cc0 = vmulq_f32(_cc0, _beta);
+                            _cc1 = vmulq_f32(_cc1, _beta);
+                        }
+#if __aarch64__
+                        _c0 = vdupq_laneq_f32(_cc0, 0);
+                        _c1 = vdupq_laneq_f32(_cc0, 1);
+                        float32x4_t _c2 = vdupq_laneq_f32(_cc0, 2);
+                        float32x4_t _c3 = vdupq_laneq_f32(_cc0, 3);
+                        float32x4_t _c4 = vdupq_laneq_f32(_cc1, 0);
+                        float32x4_t _c5 = vdupq_laneq_f32(_cc1, 1);
+                        float32x4_t _c6 = vdupq_laneq_f32(_cc1, 2);
+                        float32x4_t _c7 = vdupq_laneq_f32(_cc1, 3);
+#else
+                        _c0 = vdupq_lane_f32(vget_low_f32(_cc0), 0);
+                        _c1 = vdupq_lane_f32(vget_low_f32(_cc0), 1);
+                        float32x4_t _c2 = vdupq_lane_f32(vget_high_f32(_cc0), 0);
+                        float32x4_t _c3 = vdupq_lane_f32(vget_high_f32(_cc0), 1);
+                        float32x4_t _c4 = vdupq_lane_f32(vget_low_f32(_cc1), 0);
+                        float32x4_t _c5 = vdupq_lane_f32(vget_low_f32(_cc1), 1);
+                        float32x4_t _c6 = vdupq_lane_f32(vget_high_f32(_cc1), 0);
+                        float32x4_t _c7 = vdupq_lane_f32(vget_high_f32(_cc1), 1);
+#endif
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c2);
@@ -5965,6 +6046,27 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                    _f8 = vmulq_f32(_f8, _alpha);
+                    _f9 = vmulq_f32(_f9, _alpha);
+                    _fa = vmulq_f32(_fa, _alpha);
+                    _fb = vmulq_f32(_fb, _alpha);
+                    _fc = vmulq_f32(_fc, _alpha);
+                    _fd = vmulq_f32(_fd, _alpha);
+                    _fe = vmulq_f32(_fe, _alpha);
+                    _ff = vmulq_f32(_ff, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -6090,38 +6192,40 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                     if (broadcast_type_C == 3)
                     {
+                        float32x4_t _c2;
+                        float32x4_t _c3;
+                        float32x4_t _c4;
+                        float32x4_t _c5;
+                        float32x4_t _c6;
+                        float32x4_t _c7;
                         if (c_elempack == 1)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + c_hstep);
-                            float32x4_t _c2 = vld1q_f32(pC + c_hstep * 2);
-                            float32x4_t _c3 = vld1q_f32(pC + c_hstep * 3);
-                            float32x4_t _c4 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c5 = vld1q_f32(pC + c_hstep * 5);
-                            float32x4_t _c6 = vld1q_f32(pC + c_hstep * 6);
-                            float32x4_t _c7 = vld1q_f32(pC + c_hstep * 7);
+                            _c2 = vld1q_f32(pC + c_hstep * 2);
+                            _c3 = vld1q_f32(pC + c_hstep * 3);
+                            _c4 = vld1q_f32(pC + c_hstep * 4);
+                            _c5 = vld1q_f32(pC + c_hstep * 5);
+                            _c6 = vld1q_f32(pC + c_hstep * 6);
+                            _c7 = vld1q_f32(pC + c_hstep * 7);
                             transpose4x4_ps(_c0, _c1, _c2, _c3);
                             transpose4x4_ps(_c4, _c5, _c6, _c7);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
                             pC += 4;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + 4);
-                            float32x4_t _c2 = vld1q_f32(pC + 8);
-                            float32x4_t _c3 = vld1q_f32(pC + 12);
-                            float32x4_t _c4 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c5 = vld1q_f32(pC + c_hstep * 4 + 4);
-                            float32x4_t _c6 = vld1q_f32(pC + c_hstep * 4 + 8);
-                            float32x4_t _c7 = vld1q_f32(pC + c_hstep * 4 + 12);
+                            _c2 = vld1q_f32(pC + 8);
+                            _c3 = vld1q_f32(pC + 12);
+                            _c4 = vld1q_f32(pC + c_hstep * 4);
+                            _c5 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            _c6 = vld1q_f32(pC + c_hstep * 4 + 8);
+                            _c7 = vld1q_f32(pC + c_hstep * 4 + 12);
+                            pC += 16;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
                             _f2 = vaddq_f32(_f2, _c2);
@@ -6130,15 +6234,38 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _f5 = vaddq_f32(_f5, _c5);
                             _f6 = vaddq_f32(_f6, _c6);
                             _f7 = vaddq_f32(_f7, _c7);
-                            pC += 16;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
+                            _f4 = vmlaq_f32(_f4, _c4, _beta);
+                            _f5 = vmlaq_f32(_f5, _c5, _beta);
+                            _f6 = vmlaq_f32(_f6, _c6, _beta);
+                            _f7 = vmlaq_f32(_f7, _c7, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        _c1 = vdupq_n_f32(pC[1]);
-                        float32x4_t _c2 = vdupq_n_f32(pC[2]);
-                        float32x4_t _c3 = vdupq_n_f32(pC[3]);
+                        float32x4_t _c = vld1q_f32(pC);
+                        if (beta != 1.f)
+                        {
+                            _c = vmulq_n_f32(_c, beta);
+                        }
+#if __aarch64__
+                        _c0 = vdupq_laneq_f32(_c, 0);
+                        _c1 = vdupq_laneq_f32(_c, 1);
+                        float32x4_t _c2 = vdupq_laneq_f32(_c, 2);
+                        float32x4_t _c3 = vdupq_laneq_f32(_c, 3);
+#else
+                        _c0 = vdupq_lane_f32(vget_low_f32(_c), 0);
+                        _c1 = vdupq_lane_f32(vget_low_f32(_c), 1);
+                        float32x4_t _c2 = vdupq_lane_f32(vget_high_f32(_c), 0);
+                        float32x4_t _c3 = vdupq_lane_f32(vget_high_f32(_c), 1);
+#endif
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c2);
@@ -6151,6 +6278,19 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -6225,45 +6365,63 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                     if (broadcast_type_C == 3)
                     {
+                        float32x4_t _c2;
+                        float32x4_t _c3;
                         if (c_elempack == 1)
                         {
                             float32x2_t _cc0 = vld1_f32(pC);
                             float32x2_t _cc1 = vld1_f32(pC + c_hstep);
                             float32x2_t _cc2 = vld1_f32(pC + c_hstep * 2);
                             float32x2_t _cc3 = vld1_f32(pC + c_hstep * 3);
+                            float32x4_t _c01 = vcombine_f32(_cc0, _cc1);
+                            float32x4_t _c23 = vcombine_f32(_cc2, _cc3);
+                            float32x4x2_t _ccc0 = vuzpq_f32(_c01, _c23);
+                            _c0 = _ccc0.val[0];
+                            _c1 = _ccc0.val[1];
                             float32x2_t _cc4 = vld1_f32(pC + c_hstep * 4);
                             float32x2_t _cc5 = vld1_f32(pC + c_hstep * 5);
                             float32x2_t _cc6 = vld1_f32(pC + c_hstep * 6);
                             float32x2_t _cc7 = vld1_f32(pC + c_hstep * 7);
-                            float32x4_t _c01 = vcombine_f32(_cc0, _cc1);
-                            float32x4_t _c23 = vcombine_f32(_cc2, _cc3);
                             float32x4_t _c45 = vcombine_f32(_cc4, _cc5);
                             float32x4_t _c67 = vcombine_f32(_cc6, _cc7);
-                            float32x4x2_t _ccc0 = vuzpq_f32(_c01, _c23);
                             float32x4x2_t _ccc1 = vuzpq_f32(_c45, _c67);
-                            _f0 = vaddq_f32(_f0, _ccc0.val[0]);
-                            _f1 = vaddq_f32(_f1, _ccc0.val[1]);
-                            _f2 = vaddq_f32(_f2, _ccc1.val[0]);
-                            _f3 = vaddq_f32(_f3, _ccc1.val[1]);
+                            _c2 = _ccc1.val[0];
+                            _c3 = _ccc1.val[1];
                             pC += 2;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + 4);
-                            float32x4_t _c2 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c3 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            _c2 = vld1q_f32(pC + c_hstep * 4);
+                            _c3 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            pC += 8;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
                             _f2 = vaddq_f32(_f2, _c2);
                             _f3 = vaddq_f32(_f3, _c3);
-                            pC += 8;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        _c1 = vdupq_n_f32(pC[1]);
+                        float32x2_t _c = vld1_f32(pC);
+                        if (beta != 1.f)
+                        {
+                            _c = vmul_n_f32(_c, beta);
+                        }
+                        _c0 = vdupq_lane_f32(_c, 0);
+                        _c1 = vdupq_lane_f32(_c, 1);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -6272,6 +6430,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + out_hstep * 4, _f2);
@@ -6312,28 +6479,42 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _c1 = vsetq_lane_f32(pC[c_hstep * 5], _c1, 1);
                             _c1 = vsetq_lane_f32(pC[c_hstep * 6], _c1, 2);
                             _c1 = vsetq_lane_f32(pC[c_hstep * 7], _c1, 3);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
                             pC += 1;
                         }
                         if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + c_hstep * 4);
+                            pC += 4;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
-                            pC += 4;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
+                        _c0 = vdupq_n_f32(pC[0] * beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
                         pC += 1;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep * 4, _f1);
 
@@ -6594,54 +6775,114 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c5 = vld1q_f32(pC + c_hstep * 2 + 4);
                             float32x4_t _c6 = vld1q_f32(pC + c_hstep * 3);
                             float32x4_t _c7 = vld1q_f32(pC + c_hstep * 3 + 4);
-                            float32x4_t _c8 = vld1q_f32(pC + c_hstep * 4);
-                            float32x4_t _c9 = vld1q_f32(pC + c_hstep * 4 + 4);
-                            float32x4_t _ca = vld1q_f32(pC + c_hstep * 5);
-                            float32x4_t _cb = vld1q_f32(pC + c_hstep * 5 + 4);
-                            float32x4_t _cc = vld1q_f32(pC + c_hstep * 6);
-                            float32x4_t _cd = vld1q_f32(pC + c_hstep * 6 + 4);
-                            float32x4_t _ce = vld1q_f32(pC + c_hstep * 7);
-                            float32x4_t _cf = vld1q_f32(pC + c_hstep * 7 + 4);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
-                            _f8 = vaddq_f32(_f8, _c8);
-                            _f9 = vaddq_f32(_f9, _c9);
-                            _fa = vaddq_f32(_fa, _ca);
-                            _fb = vaddq_f32(_fb, _cb);
-                            _fc = vaddq_f32(_fc, _cc);
-                            _fd = vaddq_f32(_fd, _cd);
-                            _fe = vaddq_f32(_fe, _ce);
-                            _ff = vaddq_f32(_ff, _cf);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                                _f4 = vaddq_f32(_f4, _c4);
+                                _f5 = vaddq_f32(_f5, _c5);
+                                _f6 = vaddq_f32(_f6, _c6);
+                                _f7 = vaddq_f32(_f7, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                                _f4 = vmlaq_f32(_f4, _c4, _beta);
+                                _f5 = vmlaq_f32(_f5, _c5, _beta);
+                                _f6 = vmlaq_f32(_f6, _c6, _beta);
+                                _f7 = vmlaq_f32(_f7, _c7, _beta);
+                            }
+                            _c0 = vld1q_f32(pC + c_hstep * 4);
+                            _c1 = vld1q_f32(pC + c_hstep * 4 + 4);
+                            _c2 = vld1q_f32(pC + c_hstep * 5);
+                            _c3 = vld1q_f32(pC + c_hstep * 5 + 4);
+                            _c4 = vld1q_f32(pC + c_hstep * 6);
+                            _c5 = vld1q_f32(pC + c_hstep * 6 + 4);
+                            _c6 = vld1q_f32(pC + c_hstep * 7);
+                            _c7 = vld1q_f32(pC + c_hstep * 7 + 4);
+                            if (beta == 1.f)
+                            {
+                                _f8 = vaddq_f32(_f8, _c0);
+                                _f9 = vaddq_f32(_f9, _c1);
+                                _fa = vaddq_f32(_fa, _c2);
+                                _fb = vaddq_f32(_fb, _c3);
+                                _fc = vaddq_f32(_fc, _c4);
+                                _fd = vaddq_f32(_fd, _c5);
+                                _fe = vaddq_f32(_fe, _c6);
+                                _ff = vaddq_f32(_ff, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f8 = vmlaq_f32(_f8, _c0, _beta);
+                                _f9 = vmlaq_f32(_f9, _c1, _beta);
+                                _fa = vmlaq_f32(_fa, _c2, _beta);
+                                _fb = vmlaq_f32(_fb, _c3, _beta);
+                                _fc = vmlaq_f32(_fc, _c4, _beta);
+                                _fd = vmlaq_f32(_fd, _c5, _beta);
+                                _fe = vmlaq_f32(_fe, _c6, _beta);
+                                _ff = vmlaq_f32(_ff, _c7, _beta);
+                            }
                             pC += 8;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             float32x4x4_t _cc0 = vld4q_f32(pC);
                             float32x4x4_t _cc1 = vld4q_f32(pC + 16);
-                            float32x4x4_t _cc2 = vld4q_f32(pC + c_hstep * 4);
-                            float32x4x4_t _cc3 = vld4q_f32(pC + c_hstep * 4 + 16);
-                            _f0 = vaddq_f32(_f0, _cc0.val[0]);
-                            _f1 = vaddq_f32(_f1, _cc1.val[0]);
-                            _f2 = vaddq_f32(_f2, _cc0.val[1]);
-                            _f3 = vaddq_f32(_f3, _cc1.val[1]);
-                            _f4 = vaddq_f32(_f4, _cc0.val[2]);
-                            _f5 = vaddq_f32(_f5, _cc1.val[2]);
-                            _f6 = vaddq_f32(_f6, _cc0.val[3]);
-                            _f7 = vaddq_f32(_f7, _cc1.val[3]);
-                            _f8 = vaddq_f32(_f8, _cc2.val[0]);
-                            _f9 = vaddq_f32(_f9, _cc3.val[0]);
-                            _fa = vaddq_f32(_fa, _cc2.val[1]);
-                            _fb = vaddq_f32(_fb, _cc3.val[1]);
-                            _fc = vaddq_f32(_fc, _cc2.val[2]);
-                            _fd = vaddq_f32(_fd, _cc3.val[2]);
-                            _fe = vaddq_f32(_fe, _cc2.val[3]);
-                            _ff = vaddq_f32(_ff, _cc3.val[3]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _cc0.val[0]);
+                                _f1 = vaddq_f32(_f1, _cc1.val[0]);
+                                _f2 = vaddq_f32(_f2, _cc0.val[1]);
+                                _f3 = vaddq_f32(_f3, _cc1.val[1]);
+                                _f4 = vaddq_f32(_f4, _cc0.val[2]);
+                                _f5 = vaddq_f32(_f5, _cc1.val[2]);
+                                _f6 = vaddq_f32(_f6, _cc0.val[3]);
+                                _f7 = vaddq_f32(_f7, _cc1.val[3]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _cc0.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _cc1.val[0], _beta);
+                                _f2 = vmlaq_f32(_f2, _cc0.val[1], _beta);
+                                _f3 = vmlaq_f32(_f3, _cc1.val[1], _beta);
+                                _f4 = vmlaq_f32(_f4, _cc0.val[2], _beta);
+                                _f5 = vmlaq_f32(_f5, _cc1.val[2], _beta);
+                                _f6 = vmlaq_f32(_f6, _cc0.val[3], _beta);
+                                _f7 = vmlaq_f32(_f7, _cc1.val[3], _beta);
+                            }
+                            _cc0 = vld4q_f32(pC + c_hstep * 4);
+                            _cc1 = vld4q_f32(pC + c_hstep * 4 + 16);
+                            if (beta == 1.f)
+                            {
+                                _f8 = vaddq_f32(_f8, _cc0.val[0]);
+                                _f9 = vaddq_f32(_f9, _cc1.val[0]);
+                                _fa = vaddq_f32(_fa, _cc0.val[1]);
+                                _fb = vaddq_f32(_fb, _cc1.val[1]);
+                                _fc = vaddq_f32(_fc, _cc0.val[2]);
+                                _fd = vaddq_f32(_fd, _cc1.val[2]);
+                                _fe = vaddq_f32(_fe, _cc0.val[3]);
+                                _ff = vaddq_f32(_ff, _cc1.val[3]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f8 = vmlaq_f32(_f8, _cc0.val[0], _beta);
+                                _f9 = vmlaq_f32(_f9, _cc1.val[0], _beta);
+                                _fa = vmlaq_f32(_fa, _cc0.val[1], _beta);
+                                _fb = vmlaq_f32(_fb, _cc1.val[1], _beta);
+                                _fc = vmlaq_f32(_fc, _cc0.val[2], _beta);
+                                _fd = vmlaq_f32(_fd, _cc1.val[2], _beta);
+                                _fe = vmlaq_f32(_fe, _cc0.val[3], _beta);
+                                _ff = vmlaq_f32(_ff, _cc1.val[3], _beta);
+                            }
                             pC += 32;
                         }
                     }
@@ -6649,6 +6890,12 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     {
                         _c0 = vld1q_f32(pC);
                         _c1 = vld1q_f32(pC + 4);
+                        if (beta != 1.f)
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _c0 = vmulq_f32(_c0, _beta);
+                            _c1 = vmulq_f32(_c1, _beta);
+                        }
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -6669,6 +6916,27 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                    _f8 = vmulq_f32(_f8, _alpha);
+                    _f9 = vmulq_f32(_f9, _alpha);
+                    _fa = vmulq_f32(_fa, _alpha);
+                    _fb = vmulq_f32(_fb, _alpha);
+                    _fc = vmulq_f32(_fc, _alpha);
+                    _fd = vmulq_f32(_fd, _alpha);
+                    _fe = vmulq_f32(_fe, _alpha);
+                    _ff = vmulq_f32(_ff, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + out_hstep, _f2);
@@ -6854,34 +7122,65 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c5 = vld1q_f32(pC + c_hstep * 5);
                             float32x4_t _c6 = vld1q_f32(pC + c_hstep * 6);
                             float32x4_t _c7 = vld1q_f32(pC + c_hstep * 7);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                                _f4 = vaddq_f32(_f4, _c4);
+                                _f5 = vaddq_f32(_f5, _c5);
+                                _f6 = vaddq_f32(_f6, _c6);
+                                _f7 = vaddq_f32(_f7, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                                _f4 = vmlaq_f32(_f4, _c4, _beta);
+                                _f5 = vmlaq_f32(_f5, _c5, _beta);
+                                _f6 = vmlaq_f32(_f6, _c6, _beta);
+                                _f7 = vmlaq_f32(_f7, _c7, _beta);
+                            }
                             pC += 4;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             float32x4x4_t _cc0 = vld4q_f32(pC);
                             float32x4x4_t _cc1 = vld4q_f32(pC + c_hstep * 4);
-                            _f0 = vaddq_f32(_f0, _cc0.val[0]);
-                            _f1 = vaddq_f32(_f1, _cc0.val[1]);
-                            _f2 = vaddq_f32(_f2, _cc0.val[2]);
-                            _f3 = vaddq_f32(_f3, _cc0.val[3]);
-                            _f4 = vaddq_f32(_f4, _cc1.val[0]);
-                            _f5 = vaddq_f32(_f5, _cc1.val[1]);
-                            _f6 = vaddq_f32(_f6, _cc1.val[2]);
-                            _f7 = vaddq_f32(_f7, _cc1.val[3]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _cc0.val[0]);
+                                _f1 = vaddq_f32(_f1, _cc0.val[1]);
+                                _f2 = vaddq_f32(_f2, _cc0.val[2]);
+                                _f3 = vaddq_f32(_f3, _cc0.val[3]);
+                                _f4 = vaddq_f32(_f4, _cc1.val[0]);
+                                _f5 = vaddq_f32(_f5, _cc1.val[1]);
+                                _f6 = vaddq_f32(_f6, _cc1.val[2]);
+                                _f7 = vaddq_f32(_f7, _cc1.val[3]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _cc0.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _cc0.val[1], _beta);
+                                _f2 = vmlaq_f32(_f2, _cc0.val[2], _beta);
+                                _f3 = vmlaq_f32(_f3, _cc0.val[3], _beta);
+                                _f4 = vmlaq_f32(_f4, _cc1.val[0], _beta);
+                                _f5 = vmlaq_f32(_f5, _cc1.val[1], _beta);
+                                _f6 = vmlaq_f32(_f6, _cc1.val[2], _beta);
+                                _f7 = vmlaq_f32(_f7, _cc1.val[3], _beta);
+                            }
                             pC += 16;
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
                         _c0 = vld1q_f32(pC);
+                        _c0 = vmulq_n_f32(_c0, beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -6894,6 +7193,19 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
                 vst1q_f32(p0 + out_hstep * 2, _f2);
@@ -6995,13 +7307,28 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x2_t _cc5 = vld1_f32(pC + c_hstep * 5);
                             float32x2_t _cc6 = vld1_f32(pC + c_hstep * 6);
                             float32x2_t _cc7 = vld1_f32(pC + c_hstep * 7);
-                            _f0 = vaddq_f32(_f0, vcombine_f32(_cc0, _cc1));
-                            _f1 = vaddq_f32(_f1, vcombine_f32(_cc2, _cc3));
-                            _f2 = vaddq_f32(_f2, vcombine_f32(_cc4, _cc5));
-                            _f3 = vaddq_f32(_f3, vcombine_f32(_cc6, _cc7));
+                            _c0 = vcombine_f32(_cc0, _cc1);
+                            _c1 = vcombine_f32(_cc2, _cc3);
+                            float32x4_t _c2 = vcombine_f32(_cc4, _cc5);
+                            float32x4_t _c3 = vcombine_f32(_cc6, _cc7);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                            }
                             pC += 2;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + 4);
@@ -7009,16 +7336,28 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c3 = vld1q_f32(pC + c_hstep * 4 + 4);
                             float32x4x2_t _c01 = vzipq_f32(_c0, _c1);
                             float32x4x2_t _c23 = vzipq_f32(_c2, _c3);
-                            _f0 = vaddq_f32(_f0, _c01.val[0]);
-                            _f1 = vaddq_f32(_f1, _c01.val[1]);
-                            _f2 = vaddq_f32(_f2, _c23.val[0]);
-                            _f3 = vaddq_f32(_f3, _c23.val[1]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c01.val[0]);
+                                _f1 = vaddq_f32(_f1, _c01.val[1]);
+                                _f2 = vaddq_f32(_f2, _c23.val[0]);
+                                _f3 = vaddq_f32(_f3, _c23.val[1]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c01.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _c01.val[1], _beta);
+                                _f2 = vmlaq_f32(_f2, _c23.val[0], _beta);
+                                _f3 = vmlaq_f32(_f3, _c23.val[1], _beta);
+                            }
                             pC += 8;
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
                         float32x2_t _cc0 = vld1_f32(pC);
+                        _cc0 = vmul_n_f32(_cc0, beta);
                         _c0 = vcombine_f32(_cc0, _cc0);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
@@ -7028,6 +7367,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1_f32(p0, vget_low_f32(_f0));
                 vst1_f32(p0 + out_hstep, vget_high_f32(_f0));
                 vst1_f32(p0 + out_hstep * 2, vget_low_f32(_f1));
@@ -7072,28 +7420,42 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _c1 = vsetq_lane_f32(pC[c_hstep * 5], _c1, 1);
                             _c1 = vsetq_lane_f32(pC[c_hstep * 6], _c1, 2);
                             _c1 = vsetq_lane_f32(pC[c_hstep * 7], _c1, 3);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
                             pC += 1;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
                             _c1 = vld1q_f32(pC + c_hstep * 4);
+                            pC += 4;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
-                            pC += 4;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
+                        _c0 = vdupq_n_f32(pC[0] * beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
                         pC += 1;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 p0[0] = vgetq_lane_f32(_f0, 0);
                 p0[out_hstep] = vgetq_lane_f32(_f0, 1);
                 p0[out_hstep * 2] = vgetq_lane_f32(_f0, 2);
@@ -7119,12 +7481,13 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
         {
             if (broadcast_type_C == 0)
             {
-                _c0 = vdupq_n_f32(pC[0]);
+                _c0 = vdupq_n_f32(pC[0] * beta);
             }
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
                 _c0 = vld1q_f32(pC);
+                _c0 = vmulq_n_f32(_c0, beta);
             }
             if (broadcast_type_C == 3)
             {
@@ -7244,17 +7607,40 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                     if (broadcast_type_C == 3)
                     {
+                        float32x4_t _c1;
+                        float32x4_t _c2;
+                        float32x4_t _c3;
+                        float32x4_t _c4;
+                        float32x4_t _c5;
+                        float32x4_t _c6;
+                        float32x4_t _c7;
                         if (c_elempack == 1)
                         {
                             _c0 = vld1q_f32(pC);
-                            float32x4_t _c1 = vld1q_f32(pC + 4);
-                            float32x4_t _c2 = vld1q_f32(pC + c_hstep);
-                            float32x4_t _c3 = vld1q_f32(pC + c_hstep + 4);
-                            float32x4_t _c4 = vld1q_f32(pC + c_hstep * 2);
-                            float32x4_t _c5 = vld1q_f32(pC + c_hstep * 2 + 4);
-                            float32x4_t _c6 = vld1q_f32(pC + c_hstep * 3);
-                            float32x4_t _c7 = vld1q_f32(pC + c_hstep * 3 + 4);
+                            _c1 = vld1q_f32(pC + 4);
+                            _c2 = vld1q_f32(pC + c_hstep);
+                            _c3 = vld1q_f32(pC + c_hstep + 4);
+                            _c4 = vld1q_f32(pC + c_hstep * 2);
+                            _c5 = vld1q_f32(pC + c_hstep * 2 + 4);
+                            _c6 = vld1q_f32(pC + c_hstep * 3);
+                            _c7 = vld1q_f32(pC + c_hstep * 3 + 4);
                             transpose8x4_ps(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7);
+                            pC += 8;
+                        }
+                        else // if (c_elempack == 4)
+                        {
+                            _c0 = vld1q_f32(pC);
+                            _c1 = vld1q_f32(pC + 4);
+                            _c2 = vld1q_f32(pC + 8);
+                            _c3 = vld1q_f32(pC + 12);
+                            _c4 = vld1q_f32(pC + 16);
+                            _c5 = vld1q_f32(pC + 20);
+                            _c6 = vld1q_f32(pC + 24);
+                            _c7 = vld1q_f32(pC + 28);
+                            pC += 32;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
                             _f2 = vaddq_f32(_f2, _c2);
@@ -7263,18 +7649,51 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _f5 = vaddq_f32(_f5, _c5);
                             _f6 = vaddq_f32(_f6, _c6);
                             _f7 = vaddq_f32(_f7, _c7);
-                            pC += 8;
                         }
-                        if (c_elempack == 4)
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
+                            _f4 = vmlaq_f32(_f4, _c4, _beta);
+                            _f5 = vmlaq_f32(_f5, _c5, _beta);
+                            _f6 = vmlaq_f32(_f6, _c6, _beta);
+                            _f7 = vmlaq_f32(_f7, _c7, _beta);
+                        }
+                    }
+                    if (broadcast_type_C == 4)
+                    {
+                        float32x4_t _cc0 = vld1q_f32(pC);
+                        float32x4_t _cc1 = vld1q_f32(pC + 4);
+                        if (beta != 1.f)
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _cc0 = vmulq_f32(_cc0, _beta);
+                            _cc1 = vmulq_f32(_cc1, _beta);
+                        }
+#if __aarch64__
+                        _c0 = vdupq_laneq_f32(_cc0, 0);
+                        float32x4_t _c1 = vdupq_laneq_f32(_cc0, 1);
+                        float32x4_t _c2 = vdupq_laneq_f32(_cc0, 2);
+                        float32x4_t _c3 = vdupq_laneq_f32(_cc0, 3);
+                        float32x4_t _c4 = vdupq_laneq_f32(_cc1, 0);
+                        float32x4_t _c5 = vdupq_laneq_f32(_cc1, 1);
+                        float32x4_t _c6 = vdupq_laneq_f32(_cc1, 2);
+                        float32x4_t _c7 = vdupq_laneq_f32(_cc1, 3);
+#else
+                        _c0 = vdupq_lane_f32(vget_low_f32(_cc0), 0);
+                        float32x4_t _c1 = vdupq_lane_f32(vget_low_f32(_cc0), 1);
+                        float32x4_t _c2 = vdupq_lane_f32(vget_high_f32(_cc0), 0);
+                        float32x4_t _c3 = vdupq_lane_f32(vget_high_f32(_cc0), 1);
+                        float32x4_t _c4 = vdupq_lane_f32(vget_low_f32(_cc1), 0);
+                        float32x4_t _c5 = vdupq_lane_f32(vget_low_f32(_cc1), 1);
+                        float32x4_t _c6 = vdupq_lane_f32(vget_high_f32(_cc1), 0);
+                        float32x4_t _c7 = vdupq_lane_f32(vget_high_f32(_cc1), 1);
+#endif
+                        if (beta == 1.f)
                         {
-                            _c0 = vld1q_f32(pC);
-                            float32x4_t _c1 = vld1q_f32(pC + 4);
-                            float32x4_t _c2 = vld1q_f32(pC + 8);
-                            float32x4_t _c3 = vld1q_f32(pC + 12);
-                            float32x4_t _c4 = vld1q_f32(pC + 16);
-                            float32x4_t _c5 = vld1q_f32(pC + 20);
-                            float32x4_t _c6 = vld1q_f32(pC + 24);
-                            float32x4_t _c7 = vld1q_f32(pC + 28);
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
                             _f2 = vaddq_f32(_f2, _c2);
@@ -7283,31 +7702,36 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _f5 = vaddq_f32(_f5, _c5);
                             _f6 = vaddq_f32(_f6, _c6);
                             _f7 = vaddq_f32(_f7, _c7);
-                            pC += 32;
                         }
-                    }
-                    if (broadcast_type_C == 4)
-                    {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        float32x4_t _c1 = vdupq_n_f32(pC[1]);
-                        float32x4_t _c2 = vdupq_n_f32(pC[2]);
-                        float32x4_t _c3 = vdupq_n_f32(pC[3]);
-                        float32x4_t _c4 = vdupq_n_f32(pC[4]);
-                        float32x4_t _c5 = vdupq_n_f32(pC[5]);
-                        float32x4_t _c6 = vdupq_n_f32(pC[6]);
-                        float32x4_t _c7 = vdupq_n_f32(pC[7]);
-                        _f0 = vaddq_f32(_f0, _c0);
-                        _f1 = vaddq_f32(_f1, _c1);
-                        _f2 = vaddq_f32(_f2, _c2);
-                        _f3 = vaddq_f32(_f3, _c3);
-                        _f4 = vaddq_f32(_f4, _c4);
-                        _f5 = vaddq_f32(_f5, _c5);
-                        _f6 = vaddq_f32(_f6, _c6);
-                        _f7 = vaddq_f32(_f7, _c7);
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
+                            _f4 = vmlaq_f32(_f4, _c4, _beta);
+                            _f5 = vmlaq_f32(_f5, _c5, _beta);
+                            _f6 = vmlaq_f32(_f6, _c6, _beta);
+                            _f7 = vmlaq_f32(_f7, _c7, _beta);
+                        }
                         pC += 8;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -7385,38 +7809,60 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                     if (broadcast_type_C == 3)
                     {
+                        float32x4_t _c1;
+                        float32x4_t _c2;
+                        float32x4_t _c3;
                         if (c_elempack == 1)
                         {
                             _c0 = vld1q_f32(pC);
-                            float32x4_t _c1 = vld1q_f32(pC + c_hstep * 1);
-                            float32x4_t _c2 = vld1q_f32(pC + c_hstep * 2);
-                            float32x4_t _c3 = vld1q_f32(pC + c_hstep * 3);
+                            _c1 = vld1q_f32(pC + c_hstep * 1);
+                            _c2 = vld1q_f32(pC + c_hstep * 2);
+                            _c3 = vld1q_f32(pC + c_hstep * 3);
                             transpose4x4_ps(_c0, _c1, _c2, _c3);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
                             pC += 4;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
-                            float32x4_t _c1 = vld1q_f32(pC + 4);
-                            float32x4_t _c2 = vld1q_f32(pC + 8);
-                            float32x4_t _c3 = vld1q_f32(pC + 12);
+                            _c1 = vld1q_f32(pC + 4);
+                            _c2 = vld1q_f32(pC + 8);
+                            _c3 = vld1q_f32(pC + 12);
+                            pC += 16;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
                             _f2 = vaddq_f32(_f2, _c2);
                             _f3 = vaddq_f32(_f3, _c3);
-                            pC += 16;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        float32x4_t _c1 = vdupq_n_f32(pC[1]);
-                        float32x4_t _c2 = vdupq_n_f32(pC[2]);
-                        float32x4_t _c3 = vdupq_n_f32(pC[3]);
+                        float32x4_t _c = vld1q_f32(pC);
+                        if (beta != 1.f)
+                        {
+                            _c = vmulq_n_f32(_c, beta);
+                        }
+#if __aarch64__
+                        _c0 = vdupq_laneq_f32(_c, 0);
+                        float32x4_t _c1 = vdupq_laneq_f32(_c, 1);
+                        float32x4_t _c2 = vdupq_laneq_f32(_c, 2);
+                        float32x4_t _c3 = vdupq_laneq_f32(_c, 3);
+#else
+                        _c0 = vdupq_lane_f32(vget_low_f32(_c), 0);
+                        float32x4_t _c1 = vdupq_lane_f32(vget_low_f32(_c), 1);
+                        float32x4_t _c2 = vdupq_lane_f32(vget_high_f32(_c), 0);
+                        float32x4_t _c3 = vdupq_lane_f32(vget_high_f32(_c), 1);
+#endif
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c2);
@@ -7425,6 +7871,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -7476,6 +7931,7 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                     if (broadcast_type_C == 3)
                     {
+                        float32x4_t _c1;
                         if (c_elempack == 1)
                         {
                             float32x2_t _cc0 = vld1_f32(pC);
@@ -7485,29 +7941,50 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c01 = vcombine_f32(_cc0, _cc1);
                             float32x4_t _c23 = vcombine_f32(_cc2, _cc3);
                             float32x4x2_t _cc = vuzpq_f32(_c01, _c23);
-                            _f0 = vaddq_f32(_f0, _cc.val[0]);
-                            _f1 = vaddq_f32(_f1, _cc.val[1]);
+                            _c0 = _cc.val[0];
+                            _c1 = _cc.val[1];
                             pC += 2;
                         }
-                        if (c_elempack == 4)
+                        else // if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
-                            float32x4_t _c1 = vld1q_f32(pC + 4);
+                            _c1 = vld1q_f32(pC + 4);
+                            pC += 8;
+                        }
+                        if (beta == 1.f)
+                        {
                             _f0 = vaddq_f32(_f0, _c0);
                             _f1 = vaddq_f32(_f1, _c1);
-                            pC += 8;
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
-                        float32x4_t _c1 = vdupq_n_f32(pC[1]);
+                        float32x2_t _c = vld1_f32(pC);
+                        if (beta != 1.f)
+                        {
+                            _c = vmul_n_f32(_c, beta);
+                        }
+                        _c0 = vdupq_lane_f32(_c, 0);
+                        float32x4_t _c1 = vdupq_lane_f32(_c, 1);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         pC += 2;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
 
@@ -7536,24 +8013,35 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _c0 = vsetq_lane_f32(pC[c_hstep], _c0, 1);
                             _c0 = vsetq_lane_f32(pC[c_hstep * 2], _c0, 2);
                             _c0 = vsetq_lane_f32(pC[c_hstep * 3], _c0, 3);
-                            _f0 = vaddq_f32(_f0, _c0);
                             pC += 1;
                         }
                         if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
-                            _f0 = vaddq_f32(_f0, _c0);
                             pC += 4;
                         }
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                        }
+                        else
+                        {
+                            _f0 = vmlaq_n_f32(_f0, _c0, beta);
+                        }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
+                        _c0 = vdupq_n_f32(pC[0] * beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         pC += 1;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 vst1q_f32(p0, _f0);
 
                 pp += 4;
@@ -7709,28 +8197,58 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c5 = vld1q_f32(pC + c_hstep * 2 + 4);
                             float32x4_t _c6 = vld1q_f32(pC + c_hstep * 3);
                             float32x4_t _c7 = vld1q_f32(pC + c_hstep * 3 + 4);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
-                            _f4 = vaddq_f32(_f4, _c4);
-                            _f5 = vaddq_f32(_f5, _c5);
-                            _f6 = vaddq_f32(_f6, _c6);
-                            _f7 = vaddq_f32(_f7, _c7);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                                _f4 = vaddq_f32(_f4, _c4);
+                                _f5 = vaddq_f32(_f5, _c5);
+                                _f6 = vaddq_f32(_f6, _c6);
+                                _f7 = vaddq_f32(_f7, _c7);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                                _f4 = vmlaq_f32(_f4, _c4, _beta);
+                                _f5 = vmlaq_f32(_f5, _c5, _beta);
+                                _f6 = vmlaq_f32(_f6, _c6, _beta);
+                                _f7 = vmlaq_f32(_f7, _c7, _beta);
+                            }
                             pC += 8;
                         }
                         if (c_elempack == 4)
                         {
                             float32x4x4_t _cc0 = vld4q_f32(pC);
                             float32x4x4_t _cc1 = vld4q_f32(pC + 16);
-                            _f0 = vaddq_f32(_f0, _cc0.val[0]);
-                            _f1 = vaddq_f32(_f1, _cc1.val[0]);
-                            _f2 = vaddq_f32(_f2, _cc0.val[1]);
-                            _f3 = vaddq_f32(_f3, _cc1.val[1]);
-                            _f4 = vaddq_f32(_f4, _cc0.val[2]);
-                            _f5 = vaddq_f32(_f5, _cc1.val[2]);
-                            _f6 = vaddq_f32(_f6, _cc0.val[3]);
-                            _f7 = vaddq_f32(_f7, _cc1.val[3]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _cc0.val[0]);
+                                _f1 = vaddq_f32(_f1, _cc1.val[0]);
+                                _f2 = vaddq_f32(_f2, _cc0.val[1]);
+                                _f3 = vaddq_f32(_f3, _cc1.val[1]);
+                                _f4 = vaddq_f32(_f4, _cc0.val[2]);
+                                _f5 = vaddq_f32(_f5, _cc1.val[2]);
+                                _f6 = vaddq_f32(_f6, _cc0.val[3]);
+                                _f7 = vaddq_f32(_f7, _cc1.val[3]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _cc0.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _cc1.val[0], _beta);
+                                _f2 = vmlaq_f32(_f2, _cc0.val[1], _beta);
+                                _f3 = vmlaq_f32(_f3, _cc1.val[1], _beta);
+                                _f4 = vmlaq_f32(_f4, _cc0.val[2], _beta);
+                                _f5 = vmlaq_f32(_f5, _cc1.val[2], _beta);
+                                _f6 = vmlaq_f32(_f6, _cc0.val[3], _beta);
+                                _f7 = vmlaq_f32(_f7, _cc1.val[3], _beta);
+                            }
                             pC += 32;
                         }
                     }
@@ -7738,6 +8256,12 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     {
                         _c0 = vld1q_f32(pC);
                         float32x4_t _c1 = vld1q_f32(pC + 4);
+                        if (beta != 1.f)
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _c0 = vmulq_f32(_c0, _beta);
+                            _c1 = vmulq_f32(_c1, _beta);
+                        }
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -7750,6 +8274,19 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + out_hstep, _f2);
@@ -7863,25 +8400,48 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x4_t _c1 = vld1q_f32(pC + c_hstep * 1);
                             float32x4_t _c2 = vld1q_f32(pC + c_hstep * 2);
                             float32x4_t _c3 = vld1q_f32(pC + c_hstep * 3);
-                            _f0 = vaddq_f32(_f0, _c0);
-                            _f1 = vaddq_f32(_f1, _c1);
-                            _f2 = vaddq_f32(_f2, _c2);
-                            _f3 = vaddq_f32(_f3, _c3);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                                _f2 = vaddq_f32(_f2, _c2);
+                                _f3 = vaddq_f32(_f3, _c3);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                                _f2 = vmlaq_f32(_f2, _c2, _beta);
+                                _f3 = vmlaq_f32(_f3, _c3, _beta);
+                            }
                             pC += 4;
                         }
                         if (c_elempack == 4)
                         {
                             float32x4x4_t _c = vld4q_f32(pC);
-                            _f0 = vaddq_f32(_f0, _c.val[0]);
-                            _f1 = vaddq_f32(_f1, _c.val[1]);
-                            _f2 = vaddq_f32(_f2, _c.val[2]);
-                            _f3 = vaddq_f32(_f3, _c.val[3]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c.val[0]);
+                                _f1 = vaddq_f32(_f1, _c.val[1]);
+                                _f2 = vaddq_f32(_f2, _c.val[2]);
+                                _f3 = vaddq_f32(_f3, _c.val[3]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _c.val[1], _beta);
+                                _f2 = vmlaq_f32(_f2, _c.val[2], _beta);
+                                _f3 = vmlaq_f32(_f3, _c.val[3], _beta);
+                            }
                             pC += 16;
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
                         _c0 = vld1q_f32(pC);
+                        _c0 = vmulq_n_f32(_c0, beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -7890,6 +8450,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
                 vst1q_f32(p0 + out_hstep * 2, _f2);
@@ -7959,8 +8528,19 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             float32x2_t _cc1 = vld1_f32(pC + c_hstep);
                             float32x2_t _cc2 = vld1_f32(pC + c_hstep * 2);
                             float32x2_t _cc3 = vld1_f32(pC + c_hstep * 3);
-                            _f0 = vaddq_f32(_f0, vcombine_f32(_cc0, _cc1));
-                            _f1 = vaddq_f32(_f1, vcombine_f32(_cc2, _cc3));
+                            _c0 = vcombine_f32(_cc0, _cc1);
+                            float32x4_t _c1 = vcombine_f32(_cc2, _cc3);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c0);
+                                _f1 = vaddq_f32(_f1, _c1);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c0, _beta);
+                                _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            }
                             pC += 2;
                         }
                         if (c_elempack == 4)
@@ -7968,14 +8548,24 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _c0 = vld1q_f32(pC);
                             float32x4_t _c1 = vld1q_f32(pC + 4);
                             float32x4x2_t _c01 = vzipq_f32(_c0, _c1);
-                            _f0 = vaddq_f32(_f0, _c01.val[0]);
-                            _f1 = vaddq_f32(_f1, _c01.val[1]);
+                            if (beta == 1.f)
+                            {
+                                _f0 = vaddq_f32(_f0, _c01.val[0]);
+                                _f1 = vaddq_f32(_f1, _c01.val[1]);
+                            }
+                            else
+                            {
+                                float32x4_t _beta = vdupq_n_f32(beta);
+                                _f0 = vmlaq_f32(_f0, _c01.val[0], _beta);
+                                _f1 = vmlaq_f32(_f1, _c01.val[1], _beta);
+                            }
                             pC += 8;
                         }
                     }
                     if (broadcast_type_C == 4)
                     {
                         float32x2_t _cc0 = vld1_f32(pC);
+                        _cc0 = vmul_n_f32(_cc0, beta);
                         _c0 = vcombine_f32(_cc0, _cc0);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
@@ -7983,6 +8573,13 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1_f32(p0, vget_low_f32(_f0));
                 vst1_f32(p0 + out_hstep, vget_high_f32(_f0));
                 vst1_f32(p0 + out_hstep * 2, vget_low_f32(_f1));
@@ -8013,24 +8610,35 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                             _c0 = vsetq_lane_f32(pC[c_hstep], _c0, 1);
                             _c0 = vsetq_lane_f32(pC[c_hstep * 2], _c0, 2);
                             _c0 = vsetq_lane_f32(pC[c_hstep * 3], _c0, 3);
-                            _f0 = vaddq_f32(_f0, _c0);
                             pC += 1;
                         }
                         if (c_elempack == 4)
                         {
                             _c0 = vld1q_f32(pC);
-                            _f0 = vaddq_f32(_f0, _c0);
                             pC += 4;
                         }
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                        }
+                        else
+                        {
+                            _f0 = vmlaq_n_f32(_f0, _c0, beta);
+                        }
                     }
                     if (broadcast_type_C == 4)
                     {
-                        _c0 = vdupq_n_f32(pC[0]);
+                        _c0 = vdupq_n_f32(pC[0] * beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         pC += 1;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 p0[0] = vgetq_lane_f32(_f0, 0);
                 p0[out_hstep] = vgetq_lane_f32(_f0, 1);
                 p0[out_hstep * 2] = vgetq_lane_f32(_f0, 2);
@@ -8063,7 +8671,7 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
         {
             if (broadcast_type_C == 0)
             {
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -8071,8 +8679,8 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
-                c0 = pC[0];
-                c1 = pC[1];
+                c0 = pC[0] * beta;
+                c1 = pC[1] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
                 _c1 = vdupq_n_f32(c1);
@@ -8129,16 +8737,33 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                         _c1 = vld1q_f32(pC + 4);
                         float32x4_t _c2 = vld1q_f32(pC + c_hstep);
                         float32x4_t _c3 = vld1q_f32(pC + c_hstep + 4);
-                        _f0 = vaddq_f32(_f0, _c0);
-                        _f1 = vaddq_f32(_f1, _c1);
-                        _f2 = vaddq_f32(_f2, _c2);
-                        _f3 = vaddq_f32(_f3, _c3);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                            _f1 = vaddq_f32(_f1, _c1);
+                            _f2 = vaddq_f32(_f2, _c2);
+                            _f3 = vaddq_f32(_f3, _c3);
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
+                        }
                         pC += 8;
                     }
                     if (broadcast_type_C == 4)
                     {
                         _c0 = vld1q_f32(pC);
                         _c1 = vld1q_f32(pC + 4);
+                        if (beta != 1.f)
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _c0 = vmulq_f32(_c0, _beta);
+                            _c1 = vmulq_f32(_c1, _beta);
+                        }
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c1);
                         _f2 = vaddq_f32(_f2, _c0);
@@ -8147,6 +8772,15 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + out_hstep, _f2);
@@ -8181,19 +8815,36 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                         // c_elempack == 1
                         _c0 = vld1q_f32(pC);
                         _c1 = vld1q_f32(pC + c_hstep);
-                        _f0 = vaddq_f32(_f0, _c0);
-                        _f1 = vaddq_f32(_f1, _c1);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                            _f1 = vaddq_f32(_f1, _c1);
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                        }
                         pC += 4;
                     }
                     if (broadcast_type_C == 4)
                     {
                         _c0 = vld1q_f32(pC);
+                        _c0 = vmulq_n_f32(_c0, beta);
                         _f0 = vaddq_f32(_f0, _c0);
                         _f1 = vaddq_f32(_f1, _c0);
                         pC += 4;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
 
@@ -8227,22 +8878,50 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     if (broadcast_type_C == 3)
                     {
                         // c_elempack == 1
-                        f00 += pC[0];
-                        f01 += pC[1];
-                        f10 += pC[c_hstep];
-                        f11 += pC[c_hstep + 1];
+                        if (beta == 1.f)
+                        {
+                            f00 += pC[0];
+                            f01 += pC[1];
+                            f10 += pC[c_hstep];
+                            f11 += pC[c_hstep + 1];
+                        }
+                        else
+                        {
+                            f00 += pC[0] * beta;
+                            f01 += pC[1] * beta;
+                            f10 += pC[c_hstep] * beta;
+                            f11 += pC[c_hstep + 1] * beta;
+                        }
                         pC += 2;
                     }
                     if (broadcast_type_C == 4)
                     {
-                        f00 += pC[0];
-                        f01 += pC[1];
-                        f10 += pC[0];
-                        f11 += pC[1];
+                        if (beta == 1.f)
+                        {
+                            f00 += pC[0];
+                            f01 += pC[1];
+                            f10 += pC[0];
+                            f11 += pC[1];
+                        }
+                        else
+                        {
+                            f00 += pC[0] * beta;
+                            f01 += pC[1] * beta;
+                            f10 += pC[0] * beta;
+                            f11 += pC[1] * beta;
+                        }
                         pC += 2;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    f00 *= alpha;
+                    f01 *= alpha;
+                    f10 *= alpha;
+                    f11 *= alpha;
+                }
+
                 p0[0] = f00;
                 p0[1] = f01;
                 p0[out_hstep] = f10;
@@ -8272,18 +8951,40 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     if (broadcast_type_C == 3)
                     {
                         // c_elempack == 1
-                        f0 += pC[0];
-                        f1 += pC[c_hstep];
+                        if (beta == 1.f)
+                        {
+                            f0 += pC[0];
+                            f1 += pC[c_hstep];
+                        }
+                        else
+                        {
+                            f0 += pC[0] * beta;
+                            f1 += pC[c_hstep] * beta;
+                        }
                         pC += 1;
                     }
                     if (broadcast_type_C == 4)
                     {
-                        f0 += pC[0];
-                        f1 += pC[0];
+                        if (beta == 1.f)
+                        {
+                            f0 += pC[0];
+                            f1 += pC[0];
+                        }
+                        else
+                        {
+                            f0 += pC[0] * beta;
+                            f1 += pC[0] * beta;
+                        }
                         pC += 1;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    f0 *= alpha;
+                    f1 *= alpha;
+                }
+
                 p0[0] = f0;
                 p0[out_hstep] = f1;
 
@@ -8310,7 +9011,7 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
         {
             if (broadcast_type_C == 0)
             {
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -8318,7 +9019,7 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -8366,14 +9067,34 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                         float32x4_t _c1 = vld1q_f32(pC + 4);
                         float32x4_t _c2 = vld1q_f32(pC + 8);
                         float32x4_t _c3 = vld1q_f32(pC + 12);
-                        _f0 = vaddq_f32(_f0, _c0);
-                        _f1 = vaddq_f32(_f1, _c1);
-                        _f2 = vaddq_f32(_f2, _c2);
-                        _f3 = vaddq_f32(_f3, _c3);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                            _f1 = vaddq_f32(_f1, _c1);
+                            _f2 = vaddq_f32(_f2, _c2);
+                            _f3 = vaddq_f32(_f3, _c3);
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                            _f2 = vmlaq_f32(_f2, _c2, _beta);
+                            _f3 = vmlaq_f32(_f3, _c3, _beta);
+                        }
                         pC += 16;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -8402,12 +9123,28 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                         // out_elempack == 1
                         _c0 = vld1q_f32(pC);
                         float32x4_t _c1 = vld1q_f32(pC + 4);
-                        _f0 = vaddq_f32(_f0, _c0);
-                        _f1 = vaddq_f32(_f1, _c1);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                            _f1 = vaddq_f32(_f1, _c1);
+                        }
+                        else
+                        {
+                            float32x4_t _beta = vdupq_n_f32(beta);
+                            _f0 = vmlaq_f32(_f0, _c0, _beta);
+                            _f1 = vmlaq_f32(_f1, _c1, _beta);
+                        }
                         pC += 8;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
 
@@ -8428,11 +9165,23 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     {
                         // out_elempack == 1
                         _c0 = vld1q_f32(pC);
-                        _f0 = vaddq_f32(_f0, _c0);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vaddq_f32(_f0, _c0);
+                        }
+                        else
+                        {
+                            _f0 = vmlaq_n_f32(_f0, _c0, beta);
+                        }
                         pC += 4;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 vst1q_f32(p0, _f0);
 
                 pp += 4;
@@ -8451,11 +9200,24 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     if (broadcast_type_C == 3 || broadcast_type_C == 4)
                     {
                         // out_elempack == 1
-                        _f0 = vadd_f32(_f0, vld1_f32(pC));
+                        float32x2_t _c = vld1_f32(pC);
+                        if (beta == 1.f)
+                        {
+                            _f0 = vadd_f32(_f0, _c);
+                        }
+                        else
+                        {
+                            _f0 = vmla_n_f32(_f0, _c, beta);
+                        }
                         pC += 2;
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmul_n_f32(_f0, alpha);
+                }
+
                 vst1_f32(p0, _f0);
 
                 pp += 2;
@@ -8475,11 +9237,13 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
                     if (broadcast_type_C == 3 || broadcast_type_C == 4)
                     {
                         // out_elempack == 1
-                        f0 += pC[0];
+                        f0 += pC[0] * beta;
                         pC += 1;
                     }
                 }
 
+                f0 *= alpha;
+
                 p0[0] = f0;
 
                 pp += 1;
@@ -8489,7 +9253,7 @@ static void unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat&
     }
 }
 
-static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat& top_blob, int broadcast_type_C, int i, int max_ii, int j, int max_jj, const Mat& descales)
+static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Mat& C, Mat& top_blob, int broadcast_type_C, int i, int max_ii, int j, int max_jj, const Mat& descales, float alpha = 1.f, float beta = 1.f)
 {
 #if NCNN_RUNTIME_CPU && NCNN_ARM82DOT && __aarch64__ && !__ARM_FEATURE_DOTPROD && !__ARM_FEATURE_MATMUL_INT8
     if (ncnn::cpu_support_arm_asimddp())
@@ -8525,13 +9289,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
         {
             if (broadcast_type_C == 0)
             {
-                _c0 = vdupq_n_f32(pC[0]);
+                _c0 = vdupq_n_f32(pC[0] * beta);
             }
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
                 _c0 = vld1q_f32(pC);
                 _c1 = vld1q_f32(pC + 4);
+                _c0 = vmulq_n_f32(_c0, beta);
+                _c1 = vmulq_n_f32(_c1, beta);
             }
             if (broadcast_type_C == 3)
             {
@@ -8861,6 +9627,27 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                    _f8 = vmulq_f32(_f8, _alpha);
+                    _f9 = vmulq_f32(_f9, _alpha);
+                    _fa = vmulq_f32(_fa, _alpha);
+                    _fb = vmulq_f32(_fb, _alpha);
+                    _fc = vmulq_f32(_fc, _alpha);
+                    _fd = vmulq_f32(_fd, _alpha);
+                    _fe = vmulq_f32(_fe, _alpha);
+                    _ff = vmulq_f32(_ff, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f2);
                 vst1q_f32(p0 + 8, _f4);
@@ -9086,6 +9873,19 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -9425,6 +10225,27 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                    _f8 = vmulq_f32(_f8, _alpha);
+                    _f9 = vmulq_f32(_f9, _alpha);
+                    _fa = vmulq_f32(_fa, _alpha);
+                    _fb = vmulq_f32(_fb, _alpha);
+                    _fc = vmulq_f32(_fc, _alpha);
+                    _fd = vmulq_f32(_fd, _alpha);
+                    _fe = vmulq_f32(_fe, _alpha);
+                    _ff = vmulq_f32(_ff, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f8);
                 vst1q_f32(p0 + out_hstep, _f1);
@@ -9612,6 +10433,19 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f4);
                 vst1q_f32(p0 + out_hstep, _f1);
@@ -9733,6 +10567,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f2);
                 vst1q_f32(p0 + out_hstep, _f1);
@@ -9792,6 +10635,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 pp += 8;
@@ -9810,12 +10660,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
         {
             if (broadcast_type_C == 0)
             {
-                _c0 = vdupq_n_f32(pC[0]);
+                _c0 = vdupq_n_f32(pC[0] * beta);
             }
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
                 _c0 = vld1q_f32(pC);
+                _c0 = vmulq_n_f32(_c0, beta);
             }
             if (broadcast_type_C == 3)
             {
@@ -10011,6 +10862,19 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f2);
                 vst1q_f32(p0 + 8, _f4);
@@ -10151,6 +11015,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
                 vst1q_f32(p0 + 8, _f2);
@@ -10332,6 +11205,19 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                    _f4 = vmulq_f32(_f4, _alpha);
+                    _f5 = vmulq_f32(_f5, _alpha);
+                    _f6 = vmulq_f32(_f6, _alpha);
+                    _f7 = vmulq_f32(_f7, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
                 vst1q_f32(p0 + out_hstep * 2, _f2);
@@ -10449,6 +11335,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
                 vst1q_f32(p0 + out_hstep * 2, _f2);
@@ -10532,6 +11427,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep, _f1);
 
@@ -10578,6 +11480,11 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 pp += 4;
                 p0 += out_hstep;
@@ -10605,7 +11512,7 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
         {
             if (broadcast_type_C == 0)
             {
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -10613,8 +11520,8 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
-                c0 = pC[0];
-                c1 = pC[1];
+                c0 = pC[0] * beta;
+                c1 = pC[1] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
                 _c1 = vdupq_n_f32(c1);
@@ -10689,6 +11596,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f2);
                 vst1q_f32(p0 + out_hstep * 4, _f1);
@@ -10739,6 +11655,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + 4, _f1);
 
@@ -10820,6 +11743,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1_f32(p0, vget_low_f32(_f0));
                 vst1_f32(p0 + out_hstep, vget_high_f32(_f0));
                 vst1_f32(p0 + out_hstep * 2, vget_low_f32(_f1));
@@ -10881,6 +11813,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1_f32(p0, vget_low_f32(_f0));
                 vst1_f32(p0 + out_hstep, vget_high_f32(_f0));
                 vst1_f32(p0 + out_hstep * 2, vget_low_f32(_f1));
@@ -10934,6 +11873,14 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    f00 *= alpha;
+                    f01 *= alpha;
+                    f10 *= alpha;
+                    f11 *= alpha;
+                }
+
                 p0[0] = f00;
                 p0[1] = f01;
                 p0[out_hstep] = f10;
@@ -10975,6 +11922,12 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    f0 *= alpha;
+                    f1 *= alpha;
+                }
+
                 p0[0] = f0;
                 p0[1] = f1;
 
@@ -11000,7 +11953,7 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
         {
             if (broadcast_type_C == 0)
             {
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -11008,7 +11961,7 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
             if (broadcast_type_C == 1 || broadcast_type_C == 2)
             {
                 pC = (const float*)C + i + ii;
-                c0 = pC[0];
+                c0 = pC[0] * beta;
 #if __ARM_NEON
                 _c0 = vdupq_n_f32(c0);
 #endif
@@ -11064,6 +12017,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep * 4, _f1);
                 vst1q_f32(p0 + out_hstep * 8, _f2);
@@ -11097,6 +12059,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 vst1q_f32(p0 + out_hstep * 4, _f1);
                 pp += 8;
@@ -11121,6 +12090,11 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 vst1q_f32(p0, _f0);
                 pp += 4;
                 p0 += out_hstep * 4;
@@ -11167,6 +12141,15 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                    _f2 = vmulq_f32(_f2, _alpha);
+                    _f3 = vmulq_f32(_f3, _alpha);
+                }
+
                 p0[0] = vgetq_lane_f32(_f0, 0);
                 p0[out_hstep] = vgetq_lane_f32(_f0, 1);
                 p0[out_hstep * 2] = vgetq_lane_f32(_f0, 2);
@@ -11213,6 +12196,13 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    float32x4_t _alpha = vdupq_n_f32(alpha);
+                    _f0 = vmulq_f32(_f0, _alpha);
+                    _f1 = vmulq_f32(_f1, _alpha);
+                }
+
                 p0[0] = vgetq_lane_f32(_f0, 0);
                 p0[out_hstep] = vgetq_lane_f32(_f0, 1);
                 p0[out_hstep * 2] = vgetq_lane_f32(_f0, 2);
@@ -11244,6 +12234,11 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmulq_n_f32(_f0, alpha);
+                }
+
                 p0[0] = vgetq_lane_f32(_f0, 0);
                 p0[out_hstep] = vgetq_lane_f32(_f0, 1);
                 p0[out_hstep * 2] = vgetq_lane_f32(_f0, 2);
@@ -11270,6 +12265,11 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                if (alpha != 1.f)
+                {
+                    _f0 = vmul_n_f32(_f0, alpha);
+                }
+
                 p0[0] = vget_lane_f32(_f0, 0);
                 p0[out_hstep] = vget_lane_f32(_f0, 1);
 
@@ -11295,6 +12295,8 @@ static void transpose_unpack_output_tile_int32_to_fp32(const Mat& topT, const Ma
                     }
                 }
 
+                f0 *= alpha;
+
                 p0[0] = f0;
 
                 pp += 1;