fix fp16 conv winograd

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc

@@ -36,15 +36,15 @@ void ProcessFilterFp16(float16_t *origin_weight, float16_t *dst_weight, ConvPara
   auto input_channel = conv_param->input_channel_;
   auto output_channel = conv_param->output_channel_;
   auto kernel_plane = conv_param->kernel_w_ * conv_param->kernel_h_;
-  int iC4 = UP_DIV(input_channel, C4NUM);
+  int iC8 = UP_DIV(input_channel, C8NUM);
   int oC8 = UP_DIV(output_channel, C8NUM);
 
-  size_t tmp_size = oC8 * C8NUM * iC4 * C4NUM * kernel_plane * sizeof(float16_t);
+  size_t tmp_size = oC8 * C8NUM * iC8 * C8NUM * kernel_plane * sizeof(float16_t);
   auto tmp_addr = reinterpret_cast<float16_t *>(malloc(tmp_size));
   memset(tmp_addr, 0, tmp_size);
 
   PackWeightToC4Fp16(origin_weight, tmp_addr, conv_param);
-  Conv3x3Fp16FilterTransform(tmp_addr, dst_weight, iC4, output_channel, kernel_plane);
+  Conv3x3Fp16FilterTransform(tmp_addr, dst_weight, iC8 * 2, output_channel, kernel_plane);
 
   free(tmp_addr);
 }
@@ -52,10 +52,10 @@ void ProcessFilterFp16(float16_t *origin_weight, float16_t *dst_weight, ConvPara
 int Convolution3x3FP16CPUKernel::InitWeightBias() {
   auto input_channel = conv_param_->input_channel_;
   int output_channel = conv_param_->output_channel_;
-  int iC4 = UP_DIV(input_channel, C4NUM);
+  int iC8 = UP_DIV(input_channel, C8NUM);
   int oC8 = UP_DIV(output_channel, C8NUM);
   // init weight
-  size_t transformed_size = iC4 * C4NUM * oC8 * C8NUM * 36 * sizeof(float16_t);
+  size_t transformed_size = iC8 * C8NUM * oC8 * C8NUM * 36 * sizeof(float16_t);
   transformed_filter_addr_ = reinterpret_cast<float16_t *>(malloc(transformed_size));
   if (transformed_filter_addr_ == nullptr) {
     MS_LOG(ERROR) << "malloc transformed_filter_addr_ failed.";
@@ -92,11 +92,11 @@ int Convolution3x3FP16CPUKernel::InitWeightBias() {
 int Convolution3x3FP16CPUKernel::InitTmpBuffer() {
   const int tile_num = 16;
   const int k_plane = 36;
-  int iC4 = UP_DIV(conv_param_->input_channel_, C4NUM);
+  int iC8 = UP_DIV(conv_param_->input_channel_, C8NUM);
   int oC8 = UP_DIV(conv_param_->output_channel_, C8NUM);
 
   /*=============================tile_buffer_============================*/
-  size_t tile_buffer_size = thread_count_ * tile_num * k_plane * iC4 * C4NUM * sizeof(float16_t);
+  size_t tile_buffer_size = thread_count_ * tile_num * k_plane * iC8 * C8NUM * sizeof(float16_t);
   tile_buffer_ = reinterpret_cast<float16_t *>(malloc(tile_buffer_size));
   if (tile_buffer_ == nullptr) {
     MS_LOG(ERROR) << "malloc tile_buffer_ failed.";
@@ -105,7 +105,7 @@ int Convolution3x3FP16CPUKernel::InitTmpBuffer() {
   memset(tile_buffer_, 0, tile_buffer_size);
 
   /*=============================block_unit_buffer_============================*/
-  size_t block_unit_buffer_size = thread_count_ * k_plane * C4NUM * sizeof(float16_t);
+  size_t block_unit_buffer_size = thread_count_ * k_plane * C8NUM * sizeof(float16_t);
   block_unit_buffer_ = reinterpret_cast<float16_t *>(malloc(block_unit_buffer_size));
   if (block_unit_buffer_ == nullptr) {
     MS_LOG(ERROR) << "malloc block_unit_buffer_ failed.";
@@ -133,14 +133,14 @@ int Convolution3x3FP16CPUKernel::InitTmpBuffer() {
   memset(tmp_out_, 0, tmp_out_size);
 
   /*=============================nhwc4_input_============================*/
-  size_t nhwc4_input_size =
-    iC4 * C4NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t);
-  nhwc4_input_ = malloc(nhwc4_input_size);
+  size_t nhwc8_input_size =
+    iC8 * C8NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t);
+  nhwc4_input_ = malloc(nhwc8_input_size);
   if (nhwc4_input_ == nullptr) {
     MS_LOG(ERROR) << "malloc nhwc4_input_ failed.";
     return RET_ERROR;
   }
-  memset(nhwc4_input_, 0, nhwc4_input_size);
+  memset(nhwc4_input_, 0, nhwc8_input_size);
 
   return RET_OK;
 }
@@ -189,7 +189,6 @@ int Convolution3x3FP16CPUKernel::ReSize() {
     MS_LOG(ERROR) << "Init tmp buffer failed.";
     return RET_ERROR;
   }
-  ConfigInputOutput();
   return RET_OK;
 }
 
@@ -225,7 +224,7 @@ int Convolution3x3FP16CPUKernel::Run() {
   int in_h = conv_param_->input_h_;
   int in_w = conv_param_->input_w_;
   int in_channel = conv_param_->input_channel_;
-  convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
+  PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
   int error_code = LiteBackendParallelLaunch(Convolution3x3Fp16Impl, this, thread_count_);
   if (error_code != RET_OK) {

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc

@@ -150,10 +150,11 @@ int ConvolutionWinogradFP16CPUKernel::InitWeightBias() {
 
 int ConvolutionWinogradFP16CPUKernel::MallocFilterMatrix(int oc_block, int oc_block_num) {
   int channel_in = conv_param_->input_channel_;
-  int ic4 = UP_DIV(channel_in, BLOCK);
+  int ic8 = UP_DIV(channel_in, C8NUM);
+  int ic4 = ic8 * 2;
 
   // set data
-  auto trans_matrix_data_size = input_unit_ * input_unit_ * ic4 * C4NUM * oc_block_num * oc_block * sizeof(float);
+  auto trans_matrix_data_size = input_unit_ * input_unit_ * ic8 * C8NUM * oc_block_num * oc_block * sizeof(float);
   auto matrix_buffer = malloc(trans_matrix_data_size);
   if (matrix_buffer == nullptr) {
     MS_LOG(ERROR) << "malloc matrix_buffer failed.";
@@ -191,11 +192,11 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() {
   int channel_out = conv_param_->output_channel_;
   int output_h = conv_param_->output_h_;
   int output_w = conv_param_->output_w_;
-  int ic4 = UP_DIV(channel_in, C4NUM);
+  int ic8 = UP_DIV(channel_in, C8NUM);
   int oc8 = UP_DIV(channel_out, C8NUM);
 
   /*=============================trans_input_============================*/
-  size_t tile_buffer_size = thread_count_ * cal_num * input_unit_ * input_unit_ * ic4 * C4NUM * sizeof(float16_t);
+  size_t tile_buffer_size = thread_count_ * cal_num * input_unit_ * input_unit_ * ic8 * C8NUM * sizeof(float16_t);
   trans_input_ = reinterpret_cast<float16_t *>(malloc(tile_buffer_size));
   if (trans_input_ == nullptr) {
     MS_LOG(ERROR) << "malloc trans_input_ failed.";
@@ -223,12 +224,12 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() {
 
   /*=============================tmp_data_============================*/
   tmp_data_ =
-    reinterpret_cast<float16_t *>(malloc(thread_count_ * C4NUM * input_unit_ * input_unit_ * sizeof(float16_t)));
+    reinterpret_cast<float16_t *>(malloc(thread_count_ * C8NUM * input_unit_ * input_unit_ * sizeof(float16_t)));
   if (tmp_data_ == nullptr) {
     MS_LOG(ERROR) << "malloc tmp_data_ failed.";
     return RET_ERROR;
   }
-  memset(tmp_data_, 0, C4NUM * input_unit_ * input_unit_ * sizeof(float16_t));
+  memset(tmp_data_, 0, C8NUM * input_unit_ * input_unit_ * sizeof(float16_t));
 
   tmp_buffer_address_list_[0] = trans_input_;
   tmp_buffer_address_list_[1] = gemm_out_;
@@ -236,24 +237,18 @@ int ConvolutionWinogradFP16CPUKernel::InitTmpBuffer() {
   tmp_buffer_address_list_[3] = tmp_data_;
 
   /*=============================nhwc4_input_============================*/
-  size_t nhwc4_input_size =
-    ic4 * C4NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t);
-  nhwc4_input_ = malloc(nhwc4_input_size);
+  size_t nhwc8_input_size =
+    ic8 * C8NUM * conv_param_->input_batch_ * conv_param_->input_h_ * conv_param_->input_w_ * sizeof(float16_t);
+  nhwc4_input_ = malloc(nhwc8_input_size);
   if (nhwc4_input_ == nullptr) {
     MS_LOG(ERROR) << "malloc nhwc4_input_ failed.";
     return RET_ERROR;
   }
-  memset(nhwc4_input_, 0, nhwc4_input_size);
+  memset(nhwc4_input_, 0, nhwc8_input_size);
   return RET_OK;
 }
 
 int ConvolutionWinogradFP16CPUKernel::ConfigInputOutput() {
-  auto input_tensor = in_tensors_.at(kInputIndex);
-  auto ret = CheckLayout(input_tensor);
-  if (ret != RET_OK) {
-    MS_LOG(ERROR) << "Check layout failed.";
-    return RET_ERROR;
-  }
   auto output_tensor = out_tensors_.at(kOutputIndex);
   output_tensor->SetFormat(schema::Format_NHWC);
 
@@ -348,7 +343,7 @@ int ConvolutionWinogradFP16CPUKernel::Run() {
   int in_h = conv_param_->input_h_;
   int in_w = conv_param_->input_w_;
   int in_channel = conv_param_->input_channel_;
-  convert_func_(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel);
+  PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
   int error_code = LiteBackendParallelLaunch(ConvolutionWinogradFp16Impl, this, thread_count_);
   if (error_code != RET_OK) {

mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/conv_fp16.c

@@ -382,7 +382,8 @@ void Conv3x3Fp16(float16_t *input_data, float16_t *transed_weight, const float16
   const int tile_num = 16;
   const int output_unit = 4;
   const int k_plane = 36;
-  int ic4 = UP_DIV(conv_param->input_channel_, C4NUM);
+  int ic8 = UP_DIV(conv_param->input_channel_, C8NUM);
+  int ic4 = ic8 * 2;
   int oc8 = UP_DIV(conv_param->output_channel_, C8NUM);
 
   int out_w_block = UP_DIV(conv_param->output_w_, C4NUM);
@@ -390,7 +391,7 @@ void Conv3x3Fp16(float16_t *input_data, float16_t *transed_weight, const float16
   int output_count = out_w_block * out_h_block;
   int output_tile_count = UP_DIV(output_count, tile_num);
   int tile_buffer_offset = tile_num * k_plane * ic4 * C4NUM;
-  int block_unit_buffer_offset = k_plane * C4NUM;
+  int block_unit_buffer_offset = k_plane * C8NUM;
   int tmp_dst_buffer_offset = tile_num * k_plane * oc8 * C8NUM;
 
   int input_batch = conv_param->input_batch_;
@@ -541,7 +542,7 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa
   int input_unit = conv_param->input_unit_;
   int in_batch = conv_param->input_batch_;
   int in_channel = conv_param->input_channel_;
-  int ic4 = UP_DIV(in_channel, C4NUM);
+  int ic8 = UP_DIV(in_channel, C8NUM);
   int out_unit = conv_param->output_unit_;
   int out_w_block = UP_DIV(conv_param->output_w_, out_unit);
   int out_h_block = UP_DIV(conv_param->output_h_, out_unit);
@@ -557,16 +558,16 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa
   float16_t *gemm_out = buffer_list[1];
   float16_t *tmp_out_data = buffer_list[2];
   float16_t *tmp_data = buffer_list[3];
-  int trans_input_offset = tile_num * input_unit_square * ic4 * C4NUM;
+  int trans_input_offset = tile_num * input_unit_square * ic8 * C8NUM;
   int gemm_out_offset = tile_num * input_unit_square * oc8 * C8NUM;
-  int tmp_data_offset = input_unit_square * C4NUM;
+  int tmp_data_offset = input_unit_square * C8NUM;
   // step 1 : filter transform (pre-processed offline)
   // step 2 : input transform (online)
   for (int b = 0; b < in_batch; b++) {
-    int in_batch_offset = b * ic4 * C4NUM * conv_param->input_h_ * conv_param->input_w_;
+    int in_batch_offset = b * ic8 * C8NUM * conv_param->input_h_ * conv_param->input_w_;
     int tmp_out_batch_offset = b * out_w_block * out_h_block * out_unit * out_unit * oc8 * C8NUM;
     for (int thread_id = task_id; thread_id < output_tile_count; thread_id += thread_num) {
-      int out_tile_index = thread_id * TILE_NUM;
+      int out_tile_index = thread_id * tile_num;
       int cal_num = output_count - thread_id * tile_num;
       cal_num = cal_num > tile_num ? tile_num : cal_num;
       WinogradInputTransformFp16(input_data + in_batch_offset, trans_input + task_id * trans_input_offset,
@@ -574,7 +575,7 @@ void ConvWinogardFp16(float16_t *input_data, float16_t *trans_weight, const floa
                                  input_trans_func);
       // step 3 : gemm
       IndirectGemmFp16_16x8(gemm_out + task_id * gemm_out_offset, trans_input + task_id * trans_input_offset,
-                            trans_weight, NULL, input_unit_square, ic4, oc8 * C8NUM, output_offset, 1, 1, 0, 0);
+                            trans_weight, NULL, input_unit_square, ic8 * 2, oc8 * C8NUM, output_offset, 1, 1, 0, 0);
 
       // step 4 : output transform
       WinogradOutputTransformFp16(gemm_out + task_id * gemm_out_offset, tmp_out_data + tmp_out_batch_offset, bias_data,

mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.c

@@ -161,7 +161,8 @@ void PackWeightToC8Fp16(const float16_t *origin_weight_data, float16_t *packed_w
 void PackWeightToC4Fp16(const float16_t *origin_weight_data, float16_t *packed_weight_data, ConvParameter *conv_param) {
   // origin weight format : ohwi
   int input_channel = conv_param->input_channel_;
-  int ic4 = UP_DIV(input_channel, C4NUM);
+  int ic8 = UP_DIV(input_channel, C8NUM);
+  int ic4 = ic8 * 2;
   int output_channel = conv_param->output_channel_;
   int kernel_plane = conv_param->kernel_h_ * conv_param->kernel_w_;
 
@@ -240,6 +241,26 @@ void PackNHWCToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int c
   }
 }
 
+void PackNHWCToNHWC8Fp16(const void *src, void *dst, int batch, int plane, int channel) {
+  int ic8 = UP_DIV(channel, C8NUM);
+  int nhwc8_batch_unit_offset = ic8 * C8NUM * plane;
+  int ic_remainder_ = channel % C8NUM;
+  if (ic_remainder_ != 0) {
+    int nhwc8_batch_offset = 0;
+    for (int b = 0; b < batch; b++) {
+      int batch_offset = b * channel * plane;
+      for (int i = 0; i < plane; i++) {
+        memcpy((float16_t *)dst + nhwc8_batch_offset + i * ic8 * C8NUM, (float16_t *)src + batch_offset + i * channel,
+               channel * sizeof(float16_t));
+      }
+      nhwc8_batch_offset += nhwc8_batch_unit_offset;
+    }
+  } else {
+    size_t ori_input_size = batch * plane * channel * sizeof(float16_t);
+    memcpy(dst, src, ori_input_size);
+  }
+}
+
 void PackNHWC4ToNHWCFp16(const void *src, void *dst, int batch, int plane, int channel) {
   int c4 = UP_DIV(channel, C4NUM);
   int ic_remainder_ = channel % C4NUM;
@@ -399,19 +420,6 @@ void PackNHWC8Fp16ToNHWCFp32(float16_t *src, float *dst, int batch, int plane, i
   }
 }
 
-void PackNHWCToNHWC8Fp16(float16_t *src, float16_t *dst, int batch, int plane, int channel) {
-  int c8_channel = UP_DIV(channel, C8NUM) * C8NUM;
-  for (int b = 0; b < batch; b++) {
-    float16_t *dst_batch = dst + b * plane * c8_channel;
-    float16_t *src_batch = src + b * plane * channel;
-    for (int i = 0; i < plane; i++) {
-      float16_t *dst_plane = dst_batch + i * c8_channel;
-      float16_t *src_plane = src_batch + i * channel;
-      memcpy(dst_plane, src_plane, channel * sizeof(float16_t));
-    }
-  }
-}
-
 void PackNHWC8ToNHWCFp16(float16_t *src, float16_t *dst, int batch, int plane, int channel) {
   int c8_channel = UP_DIV(channel, C8NUM) * C8NUM;
   for (int b = 0; b < batch; b++) {

mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/pack_fp16.h

@@ -43,6 +43,8 @@ void PackNCHWToNC4HW4Fp16(const void *src, void *dst, int batch, int plane, int
 
 void PackNHWCToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int channel);
 
+void PackNHWCToNHWC8Fp16(const void *src, void *dst, int batch, int plane, int channel);
+
 void PackNHWC4ToNHWCFp16(const void *src, void *dst, int batch, int plane, int channel);
 
 void PackNCHWToNHWC4Fp16(const void *src, void *dst, int batch, int plane, int channel);
@@ -63,8 +65,6 @@ void PackNHWCFp32ToC8HWN8Fp16(float *src, float16_t *dst, int batch, int plane,
 
 void PackNHWC8Fp16ToNHWCFp32(float16_t *src, float *dst, int batch, int plane, int channel);
 
-void PackNHWCToNHWC8Fp16(float16_t *src, float16_t *dst, int batch, int plane, int channel);
-
 void PackNHWC8ToNHWCFp16(float16_t *src, float16_t *dst, int batch, int plane, int channel);
 #ifdef __cplusplus
 }

mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_transform_fp16.c

@@ -18,173 +18,209 @@
 
 // for fp16 convolution 3x3 filter/input/output transform F(4,3)
 void Conv3x3Fp16InputUnit(float16_t *tmp_data, float16_t *trans_input_data, size_t step) {
-  float16x4_t d00 = vld1_f16(tmp_data);
-  float16x4_t d01 = vld1_f16(tmp_data + 4);
-  float16x4_t d02 = vld1_f16(tmp_data + 2 * 4);
-  float16x4_t d03 = vld1_f16(tmp_data + 3 * 4);
-  float16x4_t d04 = vld1_f16(tmp_data + 4 * 4);
-  float16x4_t d05 = vld1_f16(tmp_data + 5 * 4);
-
-  float16x4_t d10 = vld1_f16(tmp_data + 6 * 4);
-  float16x4_t d11 = vld1_f16(tmp_data + 7 * 4);
-  float16x4_t d12 = vld1_f16(tmp_data + 8 * 4);
-  float16x4_t d13 = vld1_f16(tmp_data + 9 * 4);
-  float16x4_t d14 = vld1_f16(tmp_data + 10 * 4);
-  float16x4_t d15 = vld1_f16(tmp_data + 11 * 4);
-
-  float16x4_t d20 = vld1_f16(tmp_data + 12 * 4);
-  float16x4_t d21 = vld1_f16(tmp_data + 13 * 4);
-  float16x4_t d22 = vld1_f16(tmp_data + 14 * 4);
-  float16x4_t d23 = vld1_f16(tmp_data + 15 * 4);
-  float16x4_t d24 = vld1_f16(tmp_data + 16 * 4);
-  float16x4_t d25 = vld1_f16(tmp_data + 17 * 4);
-
-  float16x4_t d30 = vld1_f16(tmp_data + 18 * 4);
-  float16x4_t d31 = vld1_f16(tmp_data + 19 * 4);
-  float16x4_t d32 = vld1_f16(tmp_data + 20 * 4);
-  float16x4_t d33 = vld1_f16(tmp_data + 21 * 4);
-  float16x4_t d34 = vld1_f16(tmp_data + 22 * 4);
-  float16x4_t d35 = vld1_f16(tmp_data + 23 * 4);
-
-  float16x4_t d40 = vld1_f16(tmp_data + 24 * 4);
-  float16x4_t d41 = vld1_f16(tmp_data + 25 * 4);
-  float16x4_t d42 = vld1_f16(tmp_data + 26 * 4);
-  float16x4_t d43 = vld1_f16(tmp_data + 27 * 4);
-  float16x4_t d44 = vld1_f16(tmp_data + 28 * 4);
-  float16x4_t d45 = vld1_f16(tmp_data + 29 * 4);
-
-  float16x4_t d50 = vld1_f16(tmp_data + 30 * 4);
-  float16x4_t d51 = vld1_f16(tmp_data + 31 * 4);
-  float16x4_t d52 = vld1_f16(tmp_data + 32 * 4);
-  float16x4_t d53 = vld1_f16(tmp_data + 33 * 4);
-  float16x4_t d54 = vld1_f16(tmp_data + 34 * 4);
-  float16x4_t d55 = vld1_f16(tmp_data + 35 * 4);
-
-  float16x4_t t00 = vadd_f16(vsub_f16(vmul_n_f16(d00, 4), vmul_n_f16(d20, 5)), d40);
-  float16x4_t t01 = vadd_f16(vsub_f16(vmul_n_f16(d01, 4), vmul_n_f16(d21, 5)), d41);
-  float16x4_t t02 = vadd_f16(vsub_f16(vmul_n_f16(d02, 4), vmul_n_f16(d22, 5)), d42);
-  float16x4_t t03 = vadd_f16(vsub_f16(vmul_n_f16(d03, 4), vmul_n_f16(d23, 5)), d43);
-  float16x4_t t04 = vadd_f16(vsub_f16(vmul_n_f16(d04, 4), vmul_n_f16(d24, 5)), d44);
-  float16x4_t t05 = vadd_f16(vsub_f16(vmul_n_f16(d05, 4), vmul_n_f16(d25, 5)), d45);
-
-  float16x4_t t10 = vadd_f16(vadd_f16(d30, d40), vmul_n_f16(vadd_f16(d10, d20), -4));
-  float16x4_t t11 = vadd_f16(vadd_f16(d31, d41), vmul_n_f16(vadd_f16(d11, d21), -4));
-  float16x4_t t12 = vadd_f16(vadd_f16(d32, d42), vmul_n_f16(vadd_f16(d12, d22), -4));
-  float16x4_t t13 = vadd_f16(vadd_f16(d33, d43), vmul_n_f16(vadd_f16(d13, d23), -4));
-  float16x4_t t14 = vadd_f16(vadd_f16(d34, d44), vmul_n_f16(vadd_f16(d14, d24), -4));
-  float16x4_t t15 = vadd_f16(vadd_f16(d35, d45), vmul_n_f16(vadd_f16(d15, d25), -4));
-
-  float16x4_t t20 = vadd_f16(vsub_f16(d40, d30), vmul_n_f16(vsub_f16(d10, d20), 4));
-  float16x4_t t21 = vadd_f16(vsub_f16(d41, d31), vmul_n_f16(vsub_f16(d11, d21), 4));
-  float16x4_t t22 = vadd_f16(vsub_f16(d42, d32), vmul_n_f16(vsub_f16(d12, d22), 4));
-  float16x4_t t23 = vadd_f16(vsub_f16(d43, d33), vmul_n_f16(vsub_f16(d13, d23), 4));
-  float16x4_t t24 = vadd_f16(vsub_f16(d44, d34), vmul_n_f16(vsub_f16(d14, d24), 4));
-  float16x4_t t25 = vadd_f16(vsub_f16(d45, d35), vmul_n_f16(vsub_f16(d15, d25), 4));
-
-  float16x4_t t30 = vadd_f16(vsub_f16(d40, d20), vmul_n_f16(vsub_f16(d30, d10), 2));
-  float16x4_t t31 = vadd_f16(vsub_f16(d41, d21), vmul_n_f16(vsub_f16(d31, d11), 2));
-  float16x4_t t32 = vadd_f16(vsub_f16(d42, d22), vmul_n_f16(vsub_f16(d32, d12), 2));
-  float16x4_t t33 = vadd_f16(vsub_f16(d43, d23), vmul_n_f16(vsub_f16(d33, d13), 2));
-  float16x4_t t34 = vadd_f16(vsub_f16(d44, d24), vmul_n_f16(vsub_f16(d34, d14), 2));
-  float16x4_t t35 = vadd_f16(vsub_f16(d45, d25), vmul_n_f16(vsub_f16(d35, d15), 2));
-
-  float16x4_t t40 = vadd_f16(vsub_f16(d40, d20), vmul_n_f16(vsub_f16(d10, d30), 2));
-  float16x4_t t41 = vadd_f16(vsub_f16(d41, d21), vmul_n_f16(vsub_f16(d11, d31), 2));
-  float16x4_t t42 = vadd_f16(vsub_f16(d42, d22), vmul_n_f16(vsub_f16(d12, d32), 2));
-  float16x4_t t43 = vadd_f16(vsub_f16(d43, d23), vmul_n_f16(vsub_f16(d13, d33), 2));
-  float16x4_t t44 = vadd_f16(vsub_f16(d44, d24), vmul_n_f16(vsub_f16(d14, d34), 2));
-  float16x4_t t45 = vadd_f16(vsub_f16(d45, d25), vmul_n_f16(vsub_f16(d15, d35), 2));
-
-  float16x4_t t50 = vadd_f16(vsub_f16(vmul_n_f16(d10, 4), vmul_n_f16(d30, 5)), d50);
-  float16x4_t t51 = vadd_f16(vsub_f16(vmul_n_f16(d11, 4), vmul_n_f16(d31, 5)), d51);
-  float16x4_t t52 = vadd_f16(vsub_f16(vmul_n_f16(d12, 4), vmul_n_f16(d32, 5)), d52);
-  float16x4_t t53 = vadd_f16(vsub_f16(vmul_n_f16(d13, 4), vmul_n_f16(d33, 5)), d53);
-  float16x4_t t54 = vadd_f16(vsub_f16(vmul_n_f16(d14, 4), vmul_n_f16(d34, 5)), d54);
-  float16x4_t t55 = vadd_f16(vsub_f16(vmul_n_f16(d15, 4), vmul_n_f16(d35, 5)), d55);
-
-  float16x4_t m00 = vadd_f16(vsub_f16(vmul_n_f16(t00, 4), vmul_n_f16(t02, 5)), t04);
-  float16x4_t m01 = vadd_f16(vadd_f16(t03, t04), vmul_n_f16(vadd_f16(t01, t02), -4));
-  float16x4_t m02 = vadd_f16(vsub_f16(t04, t03), vmul_n_f16(vsub_f16(t01, t02), 4));
-  float16x4_t m03 = vadd_f16(vsub_f16(t04, t02), vmul_n_f16(vsub_f16(t03, t01), 2));
-  float16x4_t m04 = vadd_f16(vsub_f16(t04, t02), vmul_n_f16(vsub_f16(t01, t03), 2));
-  float16x4_t m05 = vadd_f16(vsub_f16(vmul_n_f16(t01, 4), vmul_n_f16(t03, 5)), t05);
-
-  float16x4_t m10 = vadd_f16(vsub_f16(vmul_n_f16(t10, 4), vmul_n_f16(t12, 5)), t14);
-  float16x4_t m11 = vadd_f16(vadd_f16(t13, t14), vmul_n_f16(vadd_f16(t11, t12), -4));
-  float16x4_t m12 = vadd_f16(vsub_f16(t14, t13), vmul_n_f16(vsub_f16(t11, t12), 4));
-  float16x4_t m13 = vadd_f16(vsub_f16(t14, t12), vmul_n_f16(vsub_f16(t13, t11), 2));
-  float16x4_t m14 = vadd_f16(vsub_f16(t14, t12), vmul_n_f16(vsub_f16(t11, t13), 2));
-  float16x4_t m15 = vadd_f16(vsub_f16(vmul_n_f16(t11, 4), vmul_n_f16(t13, 5)), t15);
-
-  float16x4_t m20 = vadd_f16(vsub_f16(vmul_n_f16(t20, 4), vmul_n_f16(t22, 5)), t24);
-  float16x4_t m21 = vadd_f16(vadd_f16(t23, t24), vmul_n_f16(vadd_f16(t21, t22), -4));
-  float16x4_t m22 = vadd_f16(vsub_f16(t24, t23), vmul_n_f16(vsub_f16(t21, t22), 4));
-  float16x4_t m23 = vadd_f16(vsub_f16(t24, t22), vmul_n_f16(vsub_f16(t23, t21), 2));
-  float16x4_t m24 = vadd_f16(vsub_f16(t24, t22), vmul_n_f16(vsub_f16(t21, t23), 2));
-  float16x4_t m25 = vadd_f16(vsub_f16(vmul_n_f16(t21, 4), vmul_n_f16(t23, 5)), t25);
-
-  float16x4_t m30 = vadd_f16(vsub_f16(vmul_n_f16(t30, 4), vmul_n_f16(t32, 5)), t34);
-  float16x4_t m31 = vadd_f16(vadd_f16(t33, t34), vmul_n_f16(vadd_f16(t31, t32), -4));
-  float16x4_t m32 = vadd_f16(vsub_f16(t34, t33), vmul_n_f16(vsub_f16(t31, t32), 4));
-  float16x4_t m33 = vadd_f16(vsub_f16(t34, t32), vmul_n_f16(vsub_f16(t33, t31), 2));
-  float16x4_t m34 = vadd_f16(vsub_f16(t34, t32), vmul_n_f16(vsub_f16(t31, t33), 2));
-  float16x4_t m35 = vadd_f16(vsub_f16(vmul_n_f16(t31, 4), vmul_n_f16(t33, 5)), t35);
-
-  float16x4_t m40 = vadd_f16(vsub_f16(vmul_n_f16(t40, 4), vmul_n_f16(t42, 5)), t44);
-  float16x4_t m41 = vadd_f16(vadd_f16(t43, t44), vmul_n_f16(vadd_f16(t41, t42), -4));
-  float16x4_t m42 = vadd_f16(vsub_f16(t44, t43), vmul_n_f16(vsub_f16(t41, t42), 4));
-  float16x4_t m43 = vadd_f16(vsub_f16(t44, t42), vmul_n_f16(vsub_f16(t43, t41), 2));
-  float16x4_t m44 = vadd_f16(vsub_f16(t44, t42), vmul_n_f16(vsub_f16(t41, t43), 2));
-  float16x4_t m45 = vadd_f16(vsub_f16(vmul_n_f16(t41, 4), vmul_n_f16(t43, 5)), t45);
-
-  float16x4_t m50 = vadd_f16(vsub_f16(vmul_n_f16(t50, 4), vmul_n_f16(t52, 5)), t54);
-  float16x4_t m51 = vadd_f16(vadd_f16(t53, t54), vmul_n_f16(vadd_f16(t51, t52), -4));
-  float16x4_t m52 = vadd_f16(vsub_f16(t54, t53), vmul_n_f16(vsub_f16(t51, t52), 4));
-  float16x4_t m53 = vadd_f16(vsub_f16(t54, t52), vmul_n_f16(vsub_f16(t53, t51), 2));
-  float16x4_t m54 = vadd_f16(vsub_f16(t54, t52), vmul_n_f16(vsub_f16(t51, t53), 2));
-  float16x4_t m55 = vadd_f16(vsub_f16(vmul_n_f16(t51, 4), vmul_n_f16(t53, 5)), t55);
-
-  vst1_f16(trans_input_data, m00);
-  vst1_f16(trans_input_data + step, m01);
-  vst1_f16(trans_input_data + 2 * step, m02);
-  vst1_f16(trans_input_data + 3 * step, m03);
-  vst1_f16(trans_input_data + 4 * step, m04);
-  vst1_f16(trans_input_data + 5 * step, m05);
-
-  vst1_f16(trans_input_data + 6 * step, m10);
-  vst1_f16(trans_input_data + 7 * step, m11);
-  vst1_f16(trans_input_data + 8 * step, m12);
-  vst1_f16(trans_input_data + 9 * step, m13);
-  vst1_f16(trans_input_data + 10 * step, m14);
-  vst1_f16(trans_input_data + 11 * step, m15);
-
-  vst1_f16(trans_input_data + 12 * step, m20);
-  vst1_f16(trans_input_data + 13 * step, m21);
-  vst1_f16(trans_input_data + 14 * step, m22);
-  vst1_f16(trans_input_data + 15 * step, m23);
-  vst1_f16(trans_input_data + 16 * step, m24);
-  vst1_f16(trans_input_data + 17 * step, m25);
-
-  vst1_f16(trans_input_data + 18 * step, m30);
-  vst1_f16(trans_input_data + 19 * step, m31);
-  vst1_f16(trans_input_data + 20 * step, m32);
-  vst1_f16(trans_input_data + 21 * step, m33);
-  vst1_f16(trans_input_data + 22 * step, m34);
-  vst1_f16(trans_input_data + 23 * step, m35);
-
-  vst1_f16(trans_input_data + 24 * step, m40);
-  vst1_f16(trans_input_data + 25 * step, m41);
-  vst1_f16(trans_input_data + 26 * step, m42);
-  vst1_f16(trans_input_data + 27 * step, m43);
-  vst1_f16(trans_input_data + 28 * step, m44);
-  vst1_f16(trans_input_data + 29 * step, m45);
-
-  vst1_f16(trans_input_data + 30 * step, m50);
-  vst1_f16(trans_input_data + 31 * step, m51);
-  vst1_f16(trans_input_data + 32 * step, m52);
-  vst1_f16(trans_input_data + 33 * step, m53);
-  vst1_f16(trans_input_data + 34 * step, m54);
-  vst1_f16(trans_input_data + 35 * step, m55);
+  float16x8_t d00 = vld1q_f16(tmp_data);
+  float16x8_t d01 = vld1q_f16(tmp_data + 8);
+  float16x8_t d02 = vld1q_f16(tmp_data + 2 * 8);
+  float16x8_t d03 = vld1q_f16(tmp_data + 3 * 8);
+  float16x8_t d04 = vld1q_f16(tmp_data + 4 * 8);
+  float16x8_t d05 = vld1q_f16(tmp_data + 5 * 8);
+
+  float16x8_t d10 = vld1q_f16(tmp_data + 6 * 8);
+  float16x8_t d11 = vld1q_f16(tmp_data + 7 * 8);
+  float16x8_t d12 = vld1q_f16(tmp_data + 8 * 8);
+  float16x8_t d13 = vld1q_f16(tmp_data + 9 * 8);
+  float16x8_t d14 = vld1q_f16(tmp_data + 10 * 8);
+  float16x8_t d15 = vld1q_f16(tmp_data + 11 * 8);
+
+  float16x8_t d20 = vld1q_f16(tmp_data + 12 * 8);
+  float16x8_t d21 = vld1q_f16(tmp_data + 13 * 8);
+  float16x8_t d22 = vld1q_f16(tmp_data + 14 * 8);
+  float16x8_t d23 = vld1q_f16(tmp_data + 15 * 8);
+  float16x8_t d24 = vld1q_f16(tmp_data + 16 * 8);
+  float16x8_t d25 = vld1q_f16(tmp_data + 17 * 8);
+
+  float16x8_t d30 = vld1q_f16(tmp_data + 18 * 8);
+  float16x8_t d31 = vld1q_f16(tmp_data + 19 * 8);
+  float16x8_t d32 = vld1q_f16(tmp_data + 20 * 8);
+  float16x8_t d33 = vld1q_f16(tmp_data + 21 * 8);
+  float16x8_t d34 = vld1q_f16(tmp_data + 22 * 8);
+  float16x8_t d35 = vld1q_f16(tmp_data + 23 * 8);
+
+  float16x8_t d40 = vld1q_f16(tmp_data + 24 * 8);
+  float16x8_t d41 = vld1q_f16(tmp_data + 25 * 8);
+  float16x8_t d42 = vld1q_f16(tmp_data + 26 * 8);
+  float16x8_t d43 = vld1q_f16(tmp_data + 27 * 8);
+  float16x8_t d44 = vld1q_f16(tmp_data + 28 * 8);
+  float16x8_t d45 = vld1q_f16(tmp_data + 29 * 8);
+
+  float16x8_t d50 = vld1q_f16(tmp_data + 30 * 8);
+  float16x8_t d51 = vld1q_f16(tmp_data + 31 * 8);
+  float16x8_t d52 = vld1q_f16(tmp_data + 32 * 8);
+  float16x8_t d53 = vld1q_f16(tmp_data + 33 * 8);
+  float16x8_t d54 = vld1q_f16(tmp_data + 34 * 8);
+  float16x8_t d55 = vld1q_f16(tmp_data + 35 * 8);
+
+  float16x8_t t00 = vaddq_f16(vsubq_f16(vmulq_n_f16(d00, 4), vmulq_n_f16(d20, 5)), d40);
+  float16x8_t t01 = vaddq_f16(vsubq_f16(vmulq_n_f16(d01, 4), vmulq_n_f16(d21, 5)), d41);
+  float16x8_t t02 = vaddq_f16(vsubq_f16(vmulq_n_f16(d02, 4), vmulq_n_f16(d22, 5)), d42);
+  float16x8_t t03 = vaddq_f16(vsubq_f16(vmulq_n_f16(d03, 4), vmulq_n_f16(d23, 5)), d43);
+  float16x8_t t04 = vaddq_f16(vsubq_f16(vmulq_n_f16(d04, 4), vmulq_n_f16(d24, 5)), d44);
+  float16x8_t t05 = vaddq_f16(vsubq_f16(vmulq_n_f16(d05, 4), vmulq_n_f16(d25, 5)), d45);
+
+  float16x8_t t10 = vaddq_f16(vaddq_f16(d30, d40), vmulq_n_f16(vaddq_f16(d10, d20), -4));
+  float16x8_t t11 = vaddq_f16(vaddq_f16(d31, d41), vmulq_n_f16(vaddq_f16(d11, d21), -4));
+  float16x8_t t12 = vaddq_f16(vaddq_f16(d32, d42), vmulq_n_f16(vaddq_f16(d12, d22), -4));
+  float16x8_t t13 = vaddq_f16(vaddq_f16(d33, d43), vmulq_n_f16(vaddq_f16(d13, d23), -4));
+  float16x8_t t14 = vaddq_f16(vaddq_f16(d34, d44), vmulq_n_f16(vaddq_f16(d14, d24), -4));
+  float16x8_t t15 = vaddq_f16(vaddq_f16(d35, d45), vmulq_n_f16(vaddq_f16(d15, d25), -4));
+
+  float16x8_t t20 = vaddq_f16(vsubq_f16(d40, d30), vmulq_n_f16(vsubq_f16(d10, d20), 4));
+  float16x8_t t21 = vaddq_f16(vsubq_f16(d41, d31), vmulq_n_f16(vsubq_f16(d11, d21), 4));
+  float16x8_t t22 = vaddq_f16(vsubq_f16(d42, d32), vmulq_n_f16(vsubq_f16(d12, d22), 4));
+  float16x8_t t23 = vaddq_f16(vsubq_f16(d43, d33), vmulq_n_f16(vsubq_f16(d13, d23), 4));
+  float16x8_t t24 = vaddq_f16(vsubq_f16(d44, d34), vmulq_n_f16(vsubq_f16(d14, d24), 4));
+  float16x8_t t25 = vaddq_f16(vsubq_f16(d45, d35), vmulq_n_f16(vsubq_f16(d15, d25), 4));
+
+  float16x8_t t30 = vaddq_f16(vsubq_f16(d40, d20), vmulq_n_f16(vsubq_f16(d30, d10), 2));
+  float16x8_t t31 = vaddq_f16(vsubq_f16(d41, d21), vmulq_n_f16(vsubq_f16(d31, d11), 2));
+  float16x8_t t32 = vaddq_f16(vsubq_f16(d42, d22), vmulq_n_f16(vsubq_f16(d32, d12), 2));
+  float16x8_t t33 = vaddq_f16(vsubq_f16(d43, d23), vmulq_n_f16(vsubq_f16(d33, d13), 2));
+  float16x8_t t34 = vaddq_f16(vsubq_f16(d44, d24), vmulq_n_f16(vsubq_f16(d34, d14), 2));
+  float16x8_t t35 = vaddq_f16(vsubq_f16(d45, d25), vmulq_n_f16(vsubq_f16(d35, d15), 2));
+
+  float16x8_t t40 = vaddq_f16(vsubq_f16(d40, d20), vmulq_n_f16(vsubq_f16(d10, d30), 2));
+  float16x8_t t41 = vaddq_f16(vsubq_f16(d41, d21), vmulq_n_f16(vsubq_f16(d11, d31), 2));
+  float16x8_t t42 = vaddq_f16(vsubq_f16(d42, d22), vmulq_n_f16(vsubq_f16(d12, d32), 2));
+  float16x8_t t43 = vaddq_f16(vsubq_f16(d43, d23), vmulq_n_f16(vsubq_f16(d13, d33), 2));
+  float16x8_t t44 = vaddq_f16(vsubq_f16(d44, d24), vmulq_n_f16(vsubq_f16(d14, d34), 2));
+  float16x8_t t45 = vaddq_f16(vsubq_f16(d45, d25), vmulq_n_f16(vsubq_f16(d15, d35), 2));
+
+  float16x8_t t50 = vaddq_f16(vsubq_f16(vmulq_n_f16(d10, 4), vmulq_n_f16(d30, 5)), d50);
+  float16x8_t t51 = vaddq_f16(vsubq_f16(vmulq_n_f16(d11, 4), vmulq_n_f16(d31, 5)), d51);
+  float16x8_t t52 = vaddq_f16(vsubq_f16(vmulq_n_f16(d12, 4), vmulq_n_f16(d32, 5)), d52);
+  float16x8_t t53 = vaddq_f16(vsubq_f16(vmulq_n_f16(d13, 4), vmulq_n_f16(d33, 5)), d53);
+  float16x8_t t54 = vaddq_f16(vsubq_f16(vmulq_n_f16(d14, 4), vmulq_n_f16(d34, 5)), d54);
+  float16x8_t t55 = vaddq_f16(vsubq_f16(vmulq_n_f16(d15, 4), vmulq_n_f16(d35, 5)), d55);
+
+  float16x8_t m00 = vaddq_f16(vsubq_f16(vmulq_n_f16(t00, 4), vmulq_n_f16(t02, 5)), t04);
+  float16x8_t m01 = vaddq_f16(vaddq_f16(t03, t04), vmulq_n_f16(vaddq_f16(t01, t02), -4));
+  float16x8_t m02 = vaddq_f16(vsubq_f16(t04, t03), vmulq_n_f16(vsubq_f16(t01, t02), 4));
+  float16x8_t m03 = vaddq_f16(vsubq_f16(t04, t02), vmulq_n_f16(vsubq_f16(t03, t01), 2));
+  float16x8_t m04 = vaddq_f16(vsubq_f16(t04, t02), vmulq_n_f16(vsubq_f16(t01, t03), 2));
+  float16x8_t m05 = vaddq_f16(vsubq_f16(vmulq_n_f16(t01, 4), vmulq_n_f16(t03, 5)), t05);
+
+  float16x8_t m10 = vaddq_f16(vsubq_f16(vmulq_n_f16(t10, 4), vmulq_n_f16(t12, 5)), t14);
+  float16x8_t m11 = vaddq_f16(vaddq_f16(t13, t14), vmulq_n_f16(vaddq_f16(t11, t12), -4));
+  float16x8_t m12 = vaddq_f16(vsubq_f16(t14, t13), vmulq_n_f16(vsubq_f16(t11, t12), 4));
+  float16x8_t m13 = vaddq_f16(vsubq_f16(t14, t12), vmulq_n_f16(vsubq_f16(t13, t11), 2));
+  float16x8_t m14 = vaddq_f16(vsubq_f16(t14, t12), vmulq_n_f16(vsubq_f16(t11, t13), 2));
+  float16x8_t m15 = vaddq_f16(vsubq_f16(vmulq_n_f16(t11, 4), vmulq_n_f16(t13, 5)), t15);
+
+  float16x8_t m20 = vaddq_f16(vsubq_f16(vmulq_n_f16(t20, 4), vmulq_n_f16(t22, 5)), t24);
+  float16x8_t m21 = vaddq_f16(vaddq_f16(t23, t24), vmulq_n_f16(vaddq_f16(t21, t22), -4));
+  float16x8_t m22 = vaddq_f16(vsubq_f16(t24, t23), vmulq_n_f16(vsubq_f16(t21, t22), 4));
+  float16x8_t m23 = vaddq_f16(vsubq_f16(t24, t22), vmulq_n_f16(vsubq_f16(t23, t21), 2));
+  float16x8_t m24 = vaddq_f16(vsubq_f16(t24, t22), vmulq_n_f16(vsubq_f16(t21, t23), 2));
+  float16x8_t m25 = vaddq_f16(vsubq_f16(vmulq_n_f16(t21, 4), vmulq_n_f16(t23, 5)), t25);
+
+  float16x8_t m30 = vaddq_f16(vsubq_f16(vmulq_n_f16(t30, 4), vmulq_n_f16(t32, 5)), t34);
+  float16x8_t m31 = vaddq_f16(vaddq_f16(t33, t34), vmulq_n_f16(vaddq_f16(t31, t32), -4));
+  float16x8_t m32 = vaddq_f16(vsubq_f16(t34, t33), vmulq_n_f16(vsubq_f16(t31, t32), 4));
+  float16x8_t m33 = vaddq_f16(vsubq_f16(t34, t32), vmulq_n_f16(vsubq_f16(t33, t31), 2));
+  float16x8_t m34 = vaddq_f16(vsubq_f16(t34, t32), vmulq_n_f16(vsubq_f16(t31, t33), 2));
+  float16x8_t m35 = vaddq_f16(vsubq_f16(vmulq_n_f16(t31, 4), vmulq_n_f16(t33, 5)), t35);
+
+  float16x8_t m40 = vaddq_f16(vsubq_f16(vmulq_n_f16(t40, 4), vmulq_n_f16(t42, 5)), t44);
+  float16x8_t m41 = vaddq_f16(vaddq_f16(t43, t44), vmulq_n_f16(vaddq_f16(t41, t42), -4));
+  float16x8_t m42 = vaddq_f16(vsubq_f16(t44, t43), vmulq_n_f16(vsubq_f16(t41, t42), 4));
+  float16x8_t m43 = vaddq_f16(vsubq_f16(t44, t42), vmulq_n_f16(vsubq_f16(t43, t41), 2));
+  float16x8_t m44 = vaddq_f16(vsubq_f16(t44, t42), vmulq_n_f16(vsubq_f16(t41, t43), 2));
+  float16x8_t m45 = vaddq_f16(vsubq_f16(vmulq_n_f16(t41, 4), vmulq_n_f16(t43, 5)), t45);
+
+  float16x8_t m50 = vaddq_f16(vsubq_f16(vmulq_n_f16(t50, 4), vmulq_n_f16(t52, 5)), t54);
+  float16x8_t m51 = vaddq_f16(vaddq_f16(t53, t54), vmulq_n_f16(vaddq_f16(t51, t52), -4));
+  float16x8_t m52 = vaddq_f16(vsubq_f16(t54, t53), vmulq_n_f16(vsubq_f16(t51, t52), 4));
+  float16x8_t m53 = vaddq_f16(vsubq_f16(t54, t52), vmulq_n_f16(vsubq_f16(t53, t51), 2));
+  float16x8_t m54 = vaddq_f16(vsubq_f16(t54, t52), vmulq_n_f16(vsubq_f16(t51, t53), 2));
+  float16x8_t m55 = vaddq_f16(vsubq_f16(vmulq_n_f16(t51, 4), vmulq_n_f16(t53, 5)), t55);
+
+  vst1_f16(trans_input_data, vget_low_f16(m00));
+  vst1_f16(trans_input_data + 64, vget_high_f16(m00));
+  vst1_f16(trans_input_data + step, vget_low_f16(m01));
+  vst1_f16(trans_input_data + step + 64, vget_high_f16(m01));
+  vst1_f16(trans_input_data + 2 * step, vget_low_f16(m02));
+  vst1_f16(trans_input_data + 2 * step + 64, vget_high_f16(m02));
+  vst1_f16(trans_input_data + 3 * step, vget_low_f16(m03));
+  vst1_f16(trans_input_data + 3 * step + 64, vget_high_f16(m03));
+  vst1_f16(trans_input_data + 4 * step, vget_low_f16(m04));
+  vst1_f16(trans_input_data + 4 * step + 64, vget_high_f16(m04));
+  vst1_f16(trans_input_data + 5 * step, vget_low_f16(m05));
+  vst1_f16(trans_input_data + 5 * step + 64, vget_high_f16(m05));
+
+  vst1_f16(trans_input_data + 6 * step, vget_low_f16(m10));
+  vst1_f16(trans_input_data + 6 * step + 64, vget_high_f16(m10));
+  vst1_f16(trans_input_data + 7 * step, vget_low_f16(m11));
+  vst1_f16(trans_input_data + 7 * step + 64, vget_high_f16(m11));
+  vst1_f16(trans_input_data + 8 * step, vget_low_f16(m12));
+  vst1_f16(trans_input_data + 8 * step + 64, vget_high_f16(m12));
+  vst1_f16(trans_input_data + 9 * step, vget_low_f16(m13));
+  vst1_f16(trans_input_data + 9 * step + 64, vget_high_f16(m13));
+  vst1_f16(trans_input_data + 10 * step, vget_low_f16(m14));
+  vst1_f16(trans_input_data + 10 * step + 64, vget_high_f16(m14));
+  vst1_f16(trans_input_data + 11 * step, vget_low_f16(m15));
+  vst1_f16(trans_input_data + 11 * step + 64, vget_high_f16(m15));
+
+  vst1_f16(trans_input_data + 12 * step, vget_low_f16(m20));
+  vst1_f16(trans_input_data + 12 * step + 64, vget_high_f16(m20));
+  vst1_f16(trans_input_data + 13 * step, vget_low_f16(m21));
+  vst1_f16(trans_input_data + 13 * step + 64, vget_high_f16(m21));
+  vst1_f16(trans_input_data + 14 * step, vget_low_f16(m22));
+  vst1_f16(trans_input_data + 14 * step + 64, vget_high_f16(m22));
+  vst1_f16(trans_input_data + 15 * step, vget_low_f16(m23));
+  vst1_f16(trans_input_data + 15 * step + 64, vget_high_f16(m23));
+  vst1_f16(trans_input_data + 16 * step, vget_low_f16(m24));
+  vst1_f16(trans_input_data + 16 * step + 64, vget_high_f16(m24));
+  vst1_f16(trans_input_data + 17 * step, vget_low_f16(m25));
+  vst1_f16(trans_input_data + 17 * step + 64, vget_high_f16(m25));
+
+  vst1_f16(trans_input_data + 18 * step, vget_low_f16(m30));
+  vst1_f16(trans_input_data + 18 * step + 64, vget_high_f16(m30));
+  vst1_f16(trans_input_data + 19 * step, vget_low_f16(m31));
+  vst1_f16(trans_input_data + 19 * step + 64, vget_high_f16(m31));
+  vst1_f16(trans_input_data + 20 * step, vget_low_f16(m32));
+  vst1_f16(trans_input_data + 20 * step + 64, vget_high_f16(m32));
+  vst1_f16(trans_input_data + 21 * step, vget_low_f16(m33));
+  vst1_f16(trans_input_data + 21 * step + 64, vget_high_f16(m33));
+  vst1_f16(trans_input_data + 22 * step, vget_low_f16(m34));
+  vst1_f16(trans_input_data + 22 * step + 64, vget_high_f16(m34));
+  vst1_f16(trans_input_data + 23 * step, vget_low_f16(m35));
+  vst1_f16(trans_input_data + 23 * step + 64, vget_high_f16(m35));
+
+  vst1_f16(trans_input_data + 24 * step, vget_low_f16(m40));
+  vst1_f16(trans_input_data + 24 * step + 64, vget_high_f16(m40));
+  vst1_f16(trans_input_data + 25 * step, vget_low_f16(m41));
+  vst1_f16(trans_input_data + 25 * step + 64, vget_high_f16(m41));
+  vst1_f16(trans_input_data + 26 * step, vget_low_f16(m42));
+  vst1_f16(trans_input_data + 26 * step + 64, vget_high_f16(m42));
+  vst1_f16(trans_input_data + 27 * step, vget_low_f16(m43));
+  vst1_f16(trans_input_data + 27 * step + 64, vget_high_f16(m43));
+  vst1_f16(trans_input_data + 28 * step, vget_low_f16(m44));
+  vst1_f16(trans_input_data + 28 * step + 64, vget_high_f16(m44));
+  vst1_f16(trans_input_data + 29 * step, vget_low_f16(m45));
+  vst1_f16(trans_input_data + 29 * step + 64, vget_high_f16(m45));
+
+  vst1_f16(trans_input_data + 30 * step, vget_low_f16(m50));
+  vst1_f16(trans_input_data + 30 * step + 64, vget_high_f16(m50));
+  vst1_f16(trans_input_data + 31 * step, vget_low_f16(m51));
+  vst1_f16(trans_input_data + 31 * step + 64, vget_high_f16(m51));
+  vst1_f16(trans_input_data + 32 * step, vget_low_f16(m52));
+  vst1_f16(trans_input_data + 32 * step + 64, vget_high_f16(m52));
+  vst1_f16(trans_input_data + 33 * step, vget_low_f16(m53));
+  vst1_f16(trans_input_data + 33 * step + 64, vget_high_f16(m53));
+  vst1_f16(trans_input_data + 34 * step, vget_low_f16(m54));
+  vst1_f16(trans_input_data + 34 * step + 64, vget_high_f16(m54));
+  vst1_f16(trans_input_data + 35 * step, vget_low_f16(m55));
+  vst1_f16(trans_input_data + 35 * step + 64, vget_high_f16(m55));
 }
 
 void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_input, float16_t *tmp_data,
@@ -196,7 +232,7 @@ void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_inp
   int input_height = conv_param->input_h_;
   int pad_w = conv_param->pad_w_;
   int pad_h = conv_param->pad_h_;
-  int ic4 = UP_DIV(input_channel, C4NUM);
+  int ic8 = UP_DIV(input_channel, C8NUM);
   if (out_w_block == 0) {
     return;
   }
@@ -209,33 +245,29 @@ void Conv3x3Fp16InputTransform(const float16_t *input_data, float16_t *trans_inp
     int real_y_start = origin_y > 0 ? 0 : -origin_y;
     int real_y_end = (origin_y + 6) < input_height ? 6 : (input_height - origin_y);
 
-    int src_plane_offset = ic4 * C4NUM * (origin_y * input_width + origin_x);
+    int src_plane_offset = ic8 * C8NUM * (origin_y * input_width + origin_x);
     int dst_plane_offset = cal_id * C4NUM;
-    for (int ic = 0; ic < ic4; ic++) {
+    for (int ic = 0; ic < ic8; ic++) {
       // clear tmp buffer
-      memset(tmp_data, 0, 6 * 6 * C4NUM * sizeof(float16_t));
+      memset(tmp_data, 0, 6 * 6 * C8NUM * sizeof(float16_t));
 
       // get real input block with padding
-      int src_ic4_offset = src_plane_offset + ic * C4NUM;
+      int src_ic4_offset = src_plane_offset + ic * C8NUM;
       for (int interval = real_y_start; interval < real_y_end; interval++) {
-        int src_y_offset = src_ic4_offset + (interval * input_width + real_x_start) * ic4 * C4NUM;
-        int dst_y_offset = interval * 6 * C4NUM + real_x_start * C4NUM;
+        int src_y_offset = src_ic4_offset + (interval * input_width + real_x_start) * ic8 * C8NUM;
+        int dst_y_offset = interval * 6 * C8NUM + real_x_start * C8NUM;
         for (int j = 0; j < (real_x_end - real_x_start); j++) {
-          int src_x_offset = src_y_offset + j * ic4 * C4NUM;
-          int dst_x_offset = dst_y_offset + j * C4NUM;
+          int src_x_offset = src_y_offset + j * ic8 * C8NUM;
+          int dst_x_offset = dst_y_offset + j * C8NUM;
           float16_t *src_addr = (float16_t *)(input_data) + src_x_offset;
           float16_t *dst_addr = tmp_data + dst_x_offset;
-          dst_addr[0] = src_addr[0];
-          dst_addr[1] = src_addr[1];
-          dst_addr[2] = src_addr[2];
-          dst_addr[3] = src_addr[3];
+          vst1q_f16(dst_addr, vld1q_f16(src_addr));
         }
       }
 
-      // todo
       // input transform
-      int dst_ic4_offset = dst_plane_offset + ic * 16 * C4NUM;
-      size_t dst_step = ic4 * C4NUM * 16;
+      int dst_ic4_offset = dst_plane_offset + ic * 16 * C8NUM;
+      size_t dst_step = ic8 * C8NUM * 16;
       float16_t *trans_input_ptr = trans_input + dst_ic4_offset;
       Conv3x3Fp16InputUnit(tmp_data, trans_input_ptr, dst_step);
     }
@@ -543,7 +575,7 @@ void WinogradInputTransformFp16(const float16_t *input_data, float16_t *trans_in
   int input_unit = conv_param->input_unit_;
   int output_unit = conv_param->output_unit_;
   int in_channel = conv_param->input_channel_;
-  int ic4 = UP_DIV(in_channel, C4NUM);
+  int ic8 = UP_DIV(in_channel, C8NUM);
   int pad_h = conv_param->pad_h_;
   int pad_w = conv_param->pad_w_;
   int input_h = conv_param->input_h_;
@@ -561,36 +593,36 @@ void WinogradInputTransformFp16(const float16_t *input_data, float16_t *trans_in
     int interval_x_e = src_x_e < input_w ? input_unit : (input_w - src_x_s);
     int interval_y_e = src_y_e < input_h ? input_unit : (input_h - src_y_s);
 
-    int src_plane_offset = ic4 * C4NUM * (src_y_s * input_w + src_x_s);
+    int src_plane_offset = ic8 * C8NUM * (src_y_s * input_w + src_x_s);
     int dst_plane_offset = c * C4NUM;
-    for (int ic = 0; ic < ic4; ic++) {
+    for (int ic = 0; ic < ic8; ic++) {
       // clear tmp buffer
-      memset(tmp_data, 0, input_unit * input_unit * C4NUM * sizeof(float16_t));
+      memset(tmp_data, 0, input_unit * input_unit * C8NUM * sizeof(float16_t));
 
       // get real input block with padding
-      int src_ic4_offset = src_plane_offset + ic * C4NUM;
+      int src_ic8_offset = src_plane_offset + ic * C8NUM;
       for (int interval = interval_y_s; interval < interval_y_e; interval++) {
-        int src_y_offset = src_ic4_offset + (interval * input_w + interval_x_s) * ic4 * C4NUM;
-        int dst_y_offset = interval * input_unit * C4NUM + interval_x_s * C4NUM;
+        int src_y_offset = src_ic8_offset + (interval * input_w + interval_x_s) * ic8 * C8NUM;
+        int dst_y_offset = interval * input_unit * C8NUM + interval_x_s * C8NUM;
         for (int j = 0; j < (interval_x_e - interval_x_s); j++) {
-          int src_x_offset = src_y_offset + j * ic4 * C4NUM;
-          int dst_x_offset = dst_y_offset + j * C4NUM;
+          int src_x_offset = src_y_offset + j * ic8 * C8NUM;
+          int dst_x_offset = dst_y_offset + j * C8NUM;
           float16_t *src_addr = input_data + src_x_offset;
           float16_t *dst_addr = tmp_data + dst_x_offset;
 #ifdef ENABLE_NEON
-          vst1_f16(dst_addr, vld1_f16(src_addr));
+          vst1q_f16(dst_addr, vld1q_f16(src_addr));
 #else
-          for (int k = 0; k < C4NUM; k++) {
+          for (int k = 0; k < C8NUM; k++) {
             dst_addr[k] = src_addr[k];
           }
 #endif
         }
       }
       // input transform
-      int dst_ic4_offset = dst_plane_offset + ic * tile_num * C4NUM;
-      size_t dst_step = ic4 * C4NUM * tile_num;
-      float16_t *trans_input_ptr = trans_input + dst_ic4_offset;
-      input_trans_func(tmp_data, trans_input_ptr, C4NUM, dst_step);
+      int dst_ic8_offset = dst_plane_offset + ic * tile_num * C8NUM;
+      size_t dst_step = ic8 * C8NUM * tile_num;
+      float16_t *trans_input_ptr = trans_input + dst_ic8_offset;
+      input_trans_func(tmp_data, trans_input_ptr, C8NUM, dst_step);
     }
     out_tile_index++;
   }  // cal_tile_num loop
@@ -612,7 +644,7 @@ void WinogradOutputTransformFp16(const float16_t *gemm_out, float16_t *tmp_out_d
     int dst_x_s = out_tile_index % output_unit_num;
     int dst_y_s = out_tile_index / output_unit_num;
     int src_tile_offset = i * oc8 * C8NUM * input_unit * input_unit;
-    int dst_tile_offset = C4NUM * output_unit * (dst_x_s + dst_y_s * output_unit_block * output_unit);
+    int dst_tile_offset = C8NUM * output_unit * (dst_x_s + dst_y_s * output_unit_block * output_unit);
 
     for (int j = 0; j < oc8; j++) {
       int src_oc8_offset = src_tile_offset + j * input_unit * input_unit * C8NUM;
@@ -620,7 +652,7 @@ void WinogradOutputTransformFp16(const float16_t *gemm_out, float16_t *tmp_out_d
         dst_tile_offset + j * C8NUM * output_unit_block * output_unit_block * output_unit * output_unit;
       const float16_t *src_ptr = gemm_out + src_oc8_offset;
       const float16_t *bias_ptr = bias_data + j * C8NUM;
-        float16_t *dst_ptr = tmp_out_data + dst_oc8_offset;
+      float16_t *dst_ptr = tmp_out_data + dst_oc8_offset;
       output_trans_func(src_ptr, dst_ptr, bias_ptr, C8NUM, output_unit_block * output_unit);
     }
     out_tile_index++;

mindspore/lite/src/runtime/kernel/arm/nnacl/fp16/winograd_utils_fp16.c

@@ -31,7 +31,6 @@ static OutputTransformUnitFp16Func outputTransformUnitFp16[] = {
 };
 
 void InputTransform4x4UnitFp16(const float16_t *src_data, float16_t *dst_data, int src_step, int dst_step) {
-#ifdef ENABLE_ARM
   float16x8_t src_data_00 = vld1q_f16(src_data + 0 * src_step);
   float16x8_t src_data_01 = vld1q_f16(src_data + 1 * src_step);
   float16x8_t src_data_02 = vld1q_f16(src_data + 2 * src_step);
@@ -89,106 +88,41 @@ void InputTransform4x4UnitFp16(const float16_t *src_data, float16_t *dst_data, i
   float16x8_t m32 = vsubq_f16(vmulq_n_f16(t32, 2), t31);
   float16x8_t m33 = vsubq_f16(t33, vmulq_n_f16(t31, 0.25));
 
-  vst1q_f16(dst_data + 0 * dst_step, m00);
-  vst1q_f16(dst_data + 1 * dst_step, m01);
-  vst1q_f16(dst_data + 2 * dst_step, m02);
-  vst1q_f16(dst_data + 3 * dst_step, m03);
-  vst1q_f16(dst_data + 4 * dst_step, m10);
-  vst1q_f16(dst_data + 5 * dst_step, m11);
-  vst1q_f16(dst_data + 6 * dst_step, m12);
-  vst1q_f16(dst_data + 7 * dst_step, m13);
-  vst1q_f16(dst_data + 8 * dst_step, m20);
-  vst1q_f16(dst_data + 9 * dst_step, m21);
-  vst1q_f16(dst_data + 10 * dst_step, m22);
-  vst1q_f16(dst_data + 11 * dst_step, m23);
-  vst1q_f16(dst_data + 12 * dst_step, m30);
-  vst1q_f16(dst_data + 13 * dst_step, m31);
-  vst1q_f16(dst_data + 14 * dst_step, m32);
-  vst1q_f16(dst_data + 15 * dst_step, m33);
-#else
-  for (int i = 0; i < C8NUM; i++) {
-    float16_t src_data_00 = src_data[i];
-    float16_t src_data_01 = src_data[i + src_step];
-    float16_t src_data_02 = src_data[i + 2 * src_step];
-    float16_t src_data_03 = src_data[i + 3 * src_step];
-    float16_t src_data_10 = src_data[i + 4 * src_step];
-    float16_t src_data_11 = src_data[i + 5 * src_step];
-    float16_t src_data_12 = src_data[i + 6 * src_step];
-    float16_t src_data_13 = src_data[i + 7 * src_step];
-    float16_t src_data_20 = src_data[i + 8 * src_step];
-    float16_t src_data_21 = src_data[i + 9 * src_step];
-    float16_t src_data_22 = src_data[i + 10 * src_step];
-    float16_t src_data_23 = src_data[i + 11 * src_step];
-    float16_t src_data_30 = src_data[i + 12 * src_step];
-    float16_t src_data_31 = src_data[i + 13 * src_step];
-    float16_t src_data_32 = src_data[i + 14 * src_step];
-    float16_t src_data_33 = src_data[i + 15 * src_step];
-
-    float16_t t00 = src_data_00 - 4 * src_data_20;
-    float16_t t01 = src_data_01 - 4 * src_data_21;
-    float16_t t02 = src_data_02 - 4 * src_data_22;
-    float16_t t03 = src_data_03 - 4 * src_data_23;
-
-    float16_t t10 = src_data_10 + 2 * src_data_20;
-    float16_t t11 = src_data_11 + 2 * src_data_21;
-    float16_t t12 = src_data_12 + 2 * src_data_22;
-    float16_t t13 = src_data_13 + 2 * src_data_23;
-
-    const float16_t t20 = 2 * src_data_20 - src_data_10;
-    const float16_t t21 = 2 * src_data_21 - src_data_11;
-    const float16_t t22 = 2 * src_data_22 - src_data_12;
-    const float16_t t23 = 2 * src_data_23 - src_data_13;
-
-    float16_t t30 = src_data_30 - 0.25f * src_data_10;
-    float16_t t31 = src_data_31 - 0.25f * src_data_11;
-    float16_t t32 = src_data_32 - 0.25f * src_data_12;
-    float16_t t33 = src_data_33 - 0.25f * src_data_13;
-
-    float16_t m00 = t00 - 4 * t02;
-    float16_t m01 = t01 + 2 * t02;
-    const float16_t m02 = 2 * t02 - t01;
-    float16_t m03 = t03 - 0.25f * t01;
-
-    float16_t m10 = t10 - 4 * t12;
-    float16_t m11 = t11 + 2 * t12;
-    const float16_t m12 = 2 * t12 - t11;
-    float16_t m13 = t13 - 0.25f * t11;
-
-    float16_t m20 = t20 - 4 * t22;
-    float16_t m21 = t21 + 2 * t22;
-    const float16_t m22 = 2 * t22 - t21;
-    float16_t m23 = t23 - 0.25f * t21;
-
-    float16_t m30 = t30 - 4 * t32;
-    const float16_t m31 = t31 + 2 * t32;
-    float16_t m32 = 2 * t32 - t31;
-    float16_t m33 = t33 - 0.25f * t31;
-
-    (dst_data + i)[0] = m00;
-    (dst_data + i + dst_step)[0] = m01;
-    (dst_data + i + 2 * dst_step)[0] = m02;
-    (dst_data + i + 3 * dst_step)[0] = m03;
-
-    (dst_data + i + 4 * dst_step)[0] = m10;
-    (dst_data + i + 5 * dst_step)[0] = m11;
-    (dst_data + i + 6 * dst_step)[0] = m12;
-    (dst_data + i + 7 * dst_step)[0] = m13;
-
-    (dst_data + i + 8 * dst_step)[0] = m20;
-    (dst_data + i + 9 * dst_step)[0] = m21;
-    (dst_data + i + 10 * dst_step)[0] = m22;
-    (dst_data + i + 11 * dst_step)[0] = m23;
-
-    (dst_data + i + 12 * dst_step)[0] = m30;
-    (dst_data + i + 13 * dst_step)[0] = m31;
-    (dst_data + i + 14 * dst_step)[0] = m32;
-    (dst_data + i + 15 * dst_step)[0] = m33;
-  }
-#endif
+  vst1_f16(dst_data, vget_low_f16(m00));
+  vst1_f16(dst_data + 64, vget_high_f16(m00));
+  vst1_f16(dst_data + 1 * dst_step, vget_low_f16(m01));
+  vst1_f16(dst_data + 1 * dst_step + 64, vget_high_f16(m01));
+  vst1_f16(dst_data + 2 * dst_step, vget_low_f16(m02));
+  vst1_f16(dst_data + 2 * dst_step + 64, vget_high_f16(m02));
+  vst1_f16(dst_data + 3 * dst_step, vget_low_f16(m03));
+  vst1_f16(dst_data + 3 * dst_step + 64, vget_high_f16(m03));
+  vst1_f16(dst_data + 4 * dst_step, vget_low_f16(m10));
+  vst1_f16(dst_data + 4 * dst_step + 64, vget_high_f16(m10));
+  vst1_f16(dst_data + 5 * dst_step, vget_low_f16(m11));
+  vst1_f16(dst_data + 5 * dst_step + 64, vget_high_f16(m11));
+  vst1_f16(dst_data + 6 * dst_step, vget_low_f16(m12));
+  vst1_f16(dst_data + 6 * dst_step + 64, vget_high_f16(m12));
+  vst1_f16(dst_data + 7 * dst_step, vget_low_f16(m13));
+  vst1_f16(dst_data + 7 * dst_step + 64, vget_high_f16(m13));
+  vst1_f16(dst_data + 8 * dst_step, vget_low_f16(m20));
+  vst1_f16(dst_data + 8 * dst_step + 64, vget_high_f16(m20));
+  vst1_f16(dst_data + 9 * dst_step, vget_low_f16(m21));
+  vst1_f16(dst_data + 9 * dst_step + 64, vget_high_f16(m21));
+  vst1_f16(dst_data + 10 * dst_step, vget_low_f16(m22));
+  vst1_f16(dst_data + 10 * dst_step + 64, vget_high_f16(m22));
+  vst1_f16(dst_data + 11 * dst_step, vget_low_f16(m23));
+  vst1_f16(dst_data + 11 * dst_step + 64, vget_high_f16(m23));
+  vst1_f16(dst_data + 12 * dst_step, vget_low_f16(m30));
+  vst1_f16(dst_data + 12 * dst_step + 64, vget_high_f16(m30));
+  vst1_f16(dst_data + 13 * dst_step, vget_low_f16(m31));
+  vst1_f16(dst_data + 13 * dst_step + 64, vget_high_f16(m31));
+  vst1_f16(dst_data + 14 * dst_step, vget_low_f16(m32));
+  vst1_f16(dst_data + 14 * dst_step + 64, vget_high_f16(m32));
+  vst1_f16(dst_data + 15 * dst_step, vget_low_f16(m33));
+  vst1_f16(dst_data + 15 * dst_step + 64, vget_high_f16(m33));
 }
 
 void InputTransform8x8UnitFp16(const float16_t *src_data, float16_t *dst_data, int src_step, int dst_step) {
-#ifdef ENABLE_ARM
   float16x8_t src_data_00 = vld1q_f16(src_data + 0 * src_step);
   float16x8_t src_data_01 = vld1q_f16(src_data + 1 * src_step);
   float16x8_t src_data_02 = vld1q_f16(src_data + 2 * src_step);
@@ -838,461 +772,134 @@ void InputTransform8x8UnitFp16(const float16_t *src_data, float16_t *dst_data, i
   float16x8_t m77 =
     vaddq_f16(vsubq_f16(vaddq_f16(vmulq_n_f16(t71, -0.5625), vmulq_n_f16(t73, 3.0625)), vmulq_n_f16(t75, 3.5)), t77);
 
-  vst1q_f16(dst_data + 0 * dst_step, m00);
-  vst1q_f16(dst_data + 1 * dst_step, m01);
-  vst1q_f16(dst_data + 2 * dst_step, m02);
-  vst1q_f16(dst_data + 3 * dst_step, m03);
-  vst1q_f16(dst_data + 4 * dst_step, m04);
-  vst1q_f16(dst_data + 5 * dst_step, m05);
-  vst1q_f16(dst_data + 6 * dst_step, m06);
-  vst1q_f16(dst_data + 7 * dst_step, m07);
-  vst1q_f16(dst_data + 8 * dst_step, m10);
-  vst1q_f16(dst_data + 9 * dst_step, m11);
-  vst1q_f16(dst_data + 10 * dst_step, m12);
-  vst1q_f16(dst_data + 11 * dst_step, m13);
-  vst1q_f16(dst_data + 12 * dst_step, m14);
-  vst1q_f16(dst_data + 13 * dst_step, m15);
-  vst1q_f16(dst_data + 14 * dst_step, m16);
-  vst1q_f16(dst_data + 15 * dst_step, m17);
-  vst1q_f16(dst_data + 16 * dst_step, m20);
-  vst1q_f16(dst_data + 17 * dst_step, m21);
-  vst1q_f16(dst_data + 18 * dst_step, m22);
-  vst1q_f16(dst_data + 19 * dst_step, m23);
-  vst1q_f16(dst_data + 20 * dst_step, m24);
-  vst1q_f16(dst_data + 21 * dst_step, m25);
-  vst1q_f16(dst_data + 22 * dst_step, m26);
-  vst1q_f16(dst_data + 23 * dst_step, m27);
-  vst1q_f16(dst_data + 24 * dst_step, m30);
-  vst1q_f16(dst_data + 25 * dst_step, m31);
-  vst1q_f16(dst_data + 26 * dst_step, m32);
-  vst1q_f16(dst_data + 27 * dst_step, m33);
-  vst1q_f16(dst_data + 28 * dst_step, m34);
-  vst1q_f16(dst_data + 29 * dst_step, m35);
-  vst1q_f16(dst_data + 30 * dst_step, m36);
-  vst1q_f16(dst_data + 31 * dst_step, m37);
-  vst1q_f16(dst_data + 32 * dst_step, m40);
-  vst1q_f16(dst_data + 33 * dst_step, m41);
-  vst1q_f16(dst_data + 34 * dst_step, m42);
-  vst1q_f16(dst_data + 35 * dst_step, m43);
-  vst1q_f16(dst_data + 36 * dst_step, m44);
-  vst1q_f16(dst_data + 37 * dst_step, m45);
-  vst1q_f16(dst_data + 38 * dst_step, m46);
-  vst1q_f16(dst_data + 39 * dst_step, m47);
-  vst1q_f16(dst_data + 40 * dst_step, m50);
-  vst1q_f16(dst_data + 41 * dst_step, m51);
-  vst1q_f16(dst_data + 42 * dst_step, m52);
-  vst1q_f16(dst_data + 43 * dst_step, m53);
-  vst1q_f16(dst_data + 44 * dst_step, m54);
-  vst1q_f16(dst_data + 45 * dst_step, m55);
-  vst1q_f16(dst_data + 46 * dst_step, m56);
-  vst1q_f16(dst_data + 47 * dst_step, m57);
-  vst1q_f16(dst_data + 48 * dst_step, m60);
-  vst1q_f16(dst_data + 49 * dst_step, m61);
-  vst1q_f16(dst_data + 50 * dst_step, m62);
-  vst1q_f16(dst_data + 51 * dst_step, m63);
-  vst1q_f16(dst_data + 52 * dst_step, m64);
-  vst1q_f16(dst_data + 53 * dst_step, m65);
-  vst1q_f16(dst_data + 54 * dst_step, m66);
-  vst1q_f16(dst_data + 55 * dst_step, m67);
-  vst1q_f16(dst_data + 56 * dst_step, m70);
-  vst1q_f16(dst_data + 57 * dst_step, m71);
-  vst1q_f16(dst_data + 58 * dst_step, m72);
-  vst1q_f16(dst_data + 59 * dst_step, m73);
-  vst1q_f16(dst_data + 60 * dst_step, m74);
-  vst1q_f16(dst_data + 61 * dst_step, m75);
-  vst1q_f16(dst_data + 62 * dst_step, m76);
-  vst1q_f16(dst_data + 63 * dst_step, m77);
-#else
-  for (int i = 0; i < C8NUM; i++) {
-    float16_t src_data_00 = src_data[i];
-    float16_t src_data_01 = src_data[i + src_step];
-    float16_t src_data_02 = src_data[i + 2 * src_step];
-    float16_t src_data_03 = src_data[i + 3 * src_step];
-    float16_t src_data_04 = src_data[i + 4 * src_step];
-    float16_t src_data_05 = src_data[i + 5 * src_step];
-    float16_t src_data_06 = src_data[i + 6 * src_step];
-    float16_t src_data_07 = src_data[i + 7 * src_step];
-    float16_t src_data_10 = src_data[i + 8 * src_step];
-    float16_t src_data_11 = src_data[i + 9 * src_step];
-    float16_t src_data_12 = src_data[i + 10 * src_step];
-    float16_t src_data_13 = src_data[i + 11 * src_step];
-    float16_t src_data_14 = src_data[i + 12 * src_step];
-    float16_t src_data_15 = src_data[i + 13 * src_step];
-    float16_t src_data_16 = src_data[i + 14 * src_step];
-    float16_t src_data_17 = src_data[i + 15 * src_step];
-    float16_t src_data_20 = src_data[i + 16 * src_step];
-    float16_t src_data_21 = src_data[i + 17 * src_step];
-    float16_t src_data_22 = src_data[i + 18 * src_step];
-    float16_t src_data_23 = src_data[i + 19 * src_step];
-    float16_t src_data_24 = src_data[i + 20 * src_step];
-    float16_t src_data_25 = src_data[i + 21 * src_step];
-    float16_t src_data_26 = src_data[i + 22 * src_step];
-    float16_t src_data_27 = src_data[i + 23 * src_step];
-    float16_t src_data_30 = src_data[i + 24 * src_step];
-    float16_t src_data_31 = src_data[i + 25 * src_step];
-    float16_t src_data_32 = src_data[i + 26 * src_step];
-    float16_t src_data_33 = src_data[i + 27 * src_step];
-    float16_t src_data_34 = src_data[i + 28 * src_step];
-    float16_t src_data_35 = src_data[i + 29 * src_step];
-    float16_t src_data_36 = src_data[i + 30 * src_step];
-    float16_t src_data_37 = src_data[i + 31 * src_step];
-    float16_t src_data_40 = src_data[i + 32 * src_step];
-    float16_t src_data_41 = src_data[i + 33 * src_step];
-    float16_t src_data_42 = src_data[i + 34 * src_step];
-    float16_t src_data_43 = src_data[i + 35 * src_step];
-    float16_t src_data_44 = src_data[i + 36 * src_step];
-    float16_t src_data_45 = src_data[i + 37 * src_step];
-    float16_t src_data_46 = src_data[i + 38 * src_step];
-    float16_t src_data_47 = src_data[i + 39 * src_step];
-    float16_t src_data_50 = src_data[i + 40 * src_step];
-    float16_t src_data_51 = src_data[i + 41 * src_step];
-    float16_t src_data_52 = src_data[i + 42 * src_step];
-    float16_t src_data_53 = src_data[i + 43 * src_step];
-    float16_t src_data_54 = src_data[i + 44 * src_step];
-    float16_t src_data_55 = src_data[i + 45 * src_step];
-    float16_t src_data_56 = src_data[i + 46 * src_step];
-    float16_t src_data_57 = src_data[i + 47 * src_step];
-    float16_t src_data_60 = src_data[i + 48 * src_step];
-    float16_t src_data_61 = src_data[i + 49 * src_step];
-    float16_t src_data_62 = src_data[i + 50 * src_step];
-    float16_t src_data_63 = src_data[i + 51 * src_step];
-    float16_t src_data_64 = src_data[i + 52 * src_step];
-    float16_t src_data_65 = src_data[i + 53 * src_step];
-    float16_t src_data_66 = src_data[i + 54 * src_step];
-    float16_t src_data_67 = src_data[i + 55 * src_step];
-    float16_t src_data_70 = src_data[i + 56 * src_step];
-    float16_t src_data_71 = src_data[i + 57 * src_step];
-    float16_t src_data_72 = src_data[i + 58 * src_step];
-    float16_t src_data_73 = src_data[i + 59 * src_step];
-    float16_t src_data_74 = src_data[i + 60 * src_step];
-    float16_t src_data_75 = src_data[i + 61 * src_step];
-    float16_t src_data_76 = src_data[i + 62 * src_step];
-    float16_t src_data_77 = src_data[i + 63 * src_step];
-
-    float16_t t00 = src_data_00 - 5.444444444444444445125f * src_data_20 + 6.222222222222222222223f * src_data_40 -
-                    1.77777777777777778f * src_data_60;
-    float16_t t01 = src_data_01 - 5.444444444444444445125f * src_data_21 + 6.222222222222222222223f * src_data_41 -
-                    1.77777777777777778f * src_data_61;
-    float16_t t02 = src_data_02 - 5.444444444444444445125f * src_data_22 + 6.222222222222222222223f * src_data_42 -
-                    1.77777777777777778f * src_data_62;
-    float16_t t03 = src_data_03 - 5.444444444444444445125f * src_data_23 + 6.222222222222222222223f * src_data_43 -
-                    1.77777777777777778f * src_data_63;
-    float16_t t04 = src_data_04 - 5.444444444444444445125f * src_data_24 + 6.222222222222222222223f * src_data_44 -
-                    1.77777777777777778f * src_data_64;
-    float16_t t05 = src_data_05 - 5.444444444444444445125f * src_data_25 + 6.222222222222222222223f * src_data_45 -
-                    1.77777777777777778f * src_data_65;
-    float16_t t06 = src_data_06 - 5.444444444444444445125f * src_data_26 + 6.222222222222222222223f * src_data_46 -
-                    1.77777777777777778f * src_data_66;
-    float16_t t07 = src_data_07 - 5.444444444444444445125f * src_data_27 + 6.222222222222222222223f * src_data_47 -
-                    1.77777777777777778f * src_data_67;
-
-    const float16_t t10 = 1.5f * src_data_10 + 3.0f * src_data_20 - 2.1666666666666667f * src_data_30 -
-                          4.333333333333333333f * src_data_40 + 0.66666666666666667f * src_data_50 +
-                          1.333333333333333f * src_data_60;
-    const float16_t t11 = 1.5f * src_data_11 + 3.0f * src_data_21 - 2.1666666666666667f * src_data_31 -
-                          4.333333333333333333f * src_data_41 + 0.66666666666666667f * src_data_51 +
-                          1.333333333333333f * src_data_61;
-    const float16_t t12 = 1.5f * src_data_12 + 3.0f * src_data_22 - 2.1666666666666667f * src_data_32 -
-                          4.333333333333333333f * src_data_42 + 0.66666666666666667f * src_data_52 +
-                          1.333333333333333f * src_data_62;
-    const float16_t t13 = 1.5f * src_data_13 + 3.0f * src_data_23 - 2.1666666666666667f * src_data_33 -
-                          4.333333333333333333f * src_data_43 + 0.66666666666666667f * src_data_53 +
-                          1.333333333333333f * src_data_63;
-    const float16_t t14 = 1.5f * src_data_14 + 3.0f * src_data_24 - 2.1666666666666667f * src_data_34 -
-                          4.333333333333333333f * src_data_44 + 0.66666666666666667f * src_data_54 +
-                          1.333333333333333f * src_data_64;
-    const float16_t t15 = 1.5f * src_data_15 + 3.0f * src_data_25 - 2.1666666666666667f * src_data_35 -
-                          4.333333333333333333f * src_data_45 + 0.66666666666666667f * src_data_55 +
-                          1.333333333333333f * src_data_65;
-    const float16_t t16 = 1.5f * src_data_16 + 3.0f * src_data_26 - 2.1666666666666667f * src_data_36 -
-                          4.333333333333333333f * src_data_46 + 0.66666666666666667f * src_data_56 +
-                          1.333333333333333f * src_data_66;
-    const float16_t t17 = 1.5f * src_data_17 + 3.0f * src_data_27 - 2.1666666666666667f * src_data_37 -
-                          4.333333333333333333f * src_data_47 + 0.66666666666666667f * src_data_57 +
-                          1.333333333333333f * src_data_67;
-
-    const float16_t t20 = -1.5f * src_data_10 + 3.0f * src_data_20 + 2.1666666666666667f * src_data_30 -
-                          4.333333333333333333f * src_data_40 - 0.66666666666666667f * src_data_50 +
-                          1.333333333333333f * src_data_60;
-    const float16_t t21 = -1.5f * src_data_11 + 3.0f * src_data_21 + 2.1666666666666667f * src_data_31 -
-                          4.333333333333333333f * src_data_41 - 0.66666666666666667f * src_data_51 +
-                          1.333333333333333f * src_data_61;
-    const float16_t t22 = -1.5f * src_data_12 + 3.0f * src_data_22 + 2.1666666666666667f * src_data_32 -
-                          4.333333333333333333f * src_data_42 - 0.66666666666666667f * src_data_52 +
-                          1.333333333333333f * src_data_62;
-    const float16_t t23 = -1.5f * src_data_13 + 3.0f * src_data_23 + 2.1666666666666667f * src_data_33 -
-                          4.333333333333333333f * src_data_43 - 0.66666666666666667f * src_data_53 +
-                          1.333333333333333f * src_data_63;
-    const float16_t t24 = -1.5f * src_data_14 + 3.0f * src_data_24 + 2.1666666666666667f * src_data_34 -
-                          4.333333333333333333f * src_data_44 - 0.66666666666666667f * src_data_54 +
-                          1.333333333333333f * src_data_64;
-    const float16_t t25 = -1.5f * src_data_15 + 3.0f * src_data_25 + 2.1666666666666667f * src_data_35 -
-                          4.333333333333333333f * src_data_45 - 0.66666666666666667f * src_data_55 +
-                          1.333333333333333f * src_data_65;
-    const float16_t t26 = -1.5f * src_data_16 + 3.0f * src_data_26 + 2.1666666666666667f * src_data_36 -
-                          4.333333333333333333f * src_data_46 - 0.66666666666666667f * src_data_56 +
-                          1.333333333333333f * src_data_66;
-    const float16_t t27 = -1.5f * src_data_17 + 3.0f * src_data_27 + 2.1666666666666667f * src_data_37 -
-                          4.333333333333333333f * src_data_47 - 0.66666666666666667f * src_data_57 +
-                          1.333333333333333f * src_data_67;
-
-    const float16_t t30 = -0.3f * (src_data_10 + src_data_20) + 1.33333333333333f * (src_data_30 + src_data_40) -
-                          0.53333333333f * (src_data_50 + src_data_60);
-    const float16_t t31 = -0.3f * (src_data_11 + src_data_21) + 1.33333333333333f * (src_data_31 + src_data_41) -
-                          0.53333333333f * (src_data_51 + src_data_61);
-    const float16_t t32 = -0.3f * (src_data_12 + src_data_22) + 1.33333333333333f * (src_data_32 + src_data_42) -
-                          0.53333333333f * (src_data_52 + src_data_62);
-    const float16_t t33 = -0.3f * (src_data_13 + src_data_23) + 1.33333333333333f * (src_data_33 + src_data_43) -
-                          0.53333333333f * (src_data_53 + src_data_63);
-    const float16_t t34 = -0.3f * (src_data_14 + src_data_24) + 1.33333333333333f * (src_data_34 + src_data_44) -
-                          0.53333333333f * (src_data_54 + src_data_64);
-    const float16_t t35 = -0.3f * (src_data_15 + src_data_25) + 1.33333333333333f * (src_data_35 + src_data_45) -
-                          0.53333333333f * (src_data_55 + src_data_65);
-    const const float16_t t36 = -0.3f * (src_data_16 + src_data_26) + 1.33333333333333f * (src_data_36 + src_data_46) -
-                                0.53333333333f * (src_data_56 + src_data_66);
-    const const float16_t t37 = -0.3f * (src_data_17 + src_data_27) + 1.33333333333333f * (src_data_37 + src_data_47) -
-                                0.53333333333f * (src_data_57 + src_data_67);
-
-    const float16_t t40 = 0.3f * (src_data_10 - src_data_20) + 1.33333333333333f * (src_data_40 - src_data_30) +
-                          0.53333333333f * (src_data_50 - src_data_60);
-    const float16_t t41 = 0.3f * (src_data_11 - src_data_21) + 1.33333333333333f * (src_data_41 - src_data_31) +
-                          0.53333333333f * (src_data_51 - src_data_61);
-    const float16_t t42 = 0.3f * (src_data_12 - src_data_22) + 1.33333333333333f * (src_data_42 - src_data_32) +
-                          0.53333333333f * (src_data_52 - src_data_62);
-    const float16_t t43 = 0.3f * (src_data_13 - src_data_23) + 1.33333333333333f * (src_data_43 - src_data_33) +
-                          0.53333333333f * (src_data_53 - src_data_63);
-    const float16_t t44 = 0.3f * (src_data_14 - src_data_24) + 1.33333333333333f * (src_data_44 - src_data_34) +
-                          0.53333333333f * (src_data_54 - src_data_64);
-    const float16_t t45 = 0.3f * (src_data_15 - src_data_25) + 1.33333333333333f * (src_data_45 - src_data_35) +
-                          0.53333333333f * (src_data_55 - src_data_65);
-    const float16_t t46 = 0.3f * (src_data_16 - src_data_26) + 1.33333333333333f * (src_data_46 - src_data_36) +
-                          0.53333333333f * (src_data_56 - src_data_66);
-    const float16_t t47 = 0.3f * (src_data_17 - src_data_27) + 1.33333333333333f * (src_data_47 - src_data_37) +
-                          0.53333333333f * (src_data_57 - src_data_67);
-
-    const float16_t t50 = 0.0333333333f * src_data_10 + 0.02222222f * src_data_20 - 0.1666666666f * src_data_30 -
-                          0.1111111111f * src_data_40 + 0.1333333f * src_data_50 + 0.0888888f * src_data_60;
-    const float16_t t51 = 0.0333333333f * src_data_11 + 0.02222222f * src_data_21 - 0.1666666666f * src_data_31 -
-                          0.1111111111f * src_data_41 + 0.1333333f * src_data_51 + 0.0888888f * src_data_61;
-    const float16_t t52 = 0.0333333333f * src_data_12 + 0.02222222f * src_data_22 - 0.1666666666f * src_data_32 -
-                          0.1111111111f * src_data_42 + 0.1333333f * src_data_52 + 0.0888888f * src_data_62;
-    const float16_t t53 = 0.0333333333f * src_data_13 + 0.02222222f * src_data_23 - 0.1666666666f * src_data_33 -
-                          0.1111111111f * src_data_43 + 0.1333333f * src_data_53 + 0.0888888f * src_data_63;
-    const float16_t t54 = 0.0333333333f * src_data_14 + 0.02222222f * src_data_24 - 0.1666666666f * src_data_34 -
-                          0.1111111111f * src_data_44 + 0.1333333f * src_data_54 + 0.0888888f * src_data_64;
-    const float16_t t55 = 0.0333333333f * src_data_15 + 0.02222222f * src_data_25 - 0.1666666666f * src_data_35 -
-                          0.1111111111f * src_data_45 + 0.1333333f * src_data_55 + 0.0888888f * src_data_65;
-    const float16_t t56 = 0.0333333333f * src_data_16 + 0.02222222f * src_data_26 - 0.1666666666f * src_data_36 -
-                          0.1111111111f * src_data_46 + 0.1333333f * src_data_56 + 0.0888888f * src_data_66;
-    const float16_t t57 = 0.0333333333f * src_data_17 + 0.02222222f * src_data_27 - 0.1666666666f * src_data_37 -
-                          0.1111111111f * src_data_47 + 0.1333333f * src_data_57 + 0.0888888f * src_data_67;
-
-    const float16_t t60 = -0.0333333333f * src_data_10 + 0.02222222f * src_data_20 + 0.1666666666f * src_data_30 -
-                          0.1111111111f * src_data_40 - 0.1333333f * src_data_50 + 0.0888888f * src_data_60;
-    const float16_t t61 = -0.0333333333f * src_data_11 + 0.02222222f * src_data_21 + 0.1666666666f * src_data_31 -
-                          0.1111111111f * src_data_41 - 0.1333333f * src_data_51 + 0.0888888f * src_data_61;
-    const float16_t t62 = -0.0333333333f * src_data_12 + 0.02222222f * src_data_22 + 0.1666666666f * src_data_32 -
-                          0.1111111111f * src_data_42 - 0.1333333f * src_data_52 + 0.0888888f * src_data_62;
-    const float16_t t63 = -0.0333333333f * src_data_13 + 0.02222222f * src_data_23 + 0.1666666666f * src_data_33 -
-                          0.1111111111f * src_data_43 - 0.1333333f * src_data_53 + 0.0888888f * src_data_63;
-    const float16_t t64 = -0.0333333333f * src_data_14 + 0.02222222f * src_data_24 + 0.1666666666f * src_data_34 -
-                          0.1111111111f * src_data_44 - 0.1333333f * src_data_54 + 0.0888888f * src_data_64;
-    const float16_t t65 = -0.0333333333f * src_data_15 + 0.02222222f * src_data_25 + 0.1666666666f * src_data_35 -
-                          0.1111111111f * src_data_45 - 0.1333333f * src_data_55 + 0.0888888f * src_data_65;
-    const float16_t t66 = -0.0333333333f * src_data_16 + 0.02222222f * src_data_26 + 0.1666666666f * src_data_36 -
-                          0.1111111111f * src_data_46 - 0.1333333f * src_data_56 + 0.0888888f * src_data_66;
-    const float16_t t67 = -0.0333333333f * src_data_17 + 0.02222222f * src_data_27 + 0.1666666666f * src_data_37 -
-                          0.1111111111f * src_data_47 - 0.1333333f * src_data_57 + 0.0888888f * src_data_67;
-
-    const float16_t t70 = -0.5625f * src_data_10 + 3.0625f * src_data_30 - 3.5f * src_data_50 + src_data_70;
-    const float16_t t71 = -0.5625f * src_data_11 + 3.0625f * src_data_31 - 3.5f * src_data_51 + src_data_71;
-    const float16_t t72 = -0.5625f * src_data_12 + 3.0625f * src_data_32 - 3.5f * src_data_52 + src_data_72;
-    const float16_t t73 = -0.5625f * src_data_13 + 3.0625f * src_data_33 - 3.5f * src_data_53 + src_data_73;
-    const float16_t t74 = -0.5625f * src_data_14 + 3.0625f * src_data_34 - 3.5f * src_data_54 + src_data_74;
-    const float16_t t75 = -0.5625f * src_data_15 + 3.0625f * src_data_35 - 3.5f * src_data_55 + src_data_75;
-    const float16_t t76 = -0.5625f * src_data_16 + 3.0625f * src_data_36 - 3.5f * src_data_56 + src_data_76;
-    const float16_t t77 = -0.5625f * src_data_17 + 3.0625f * src_data_37 - 3.5f * src_data_57 + src_data_77;
-
-    const float16_t m00 =
-      t00 - 5.444444444444444445125f * t02 + 6.222222222222222222223f * t04 - 1.77777777777777778f * t06;
-    const float16_t m01 = 1.5f * t01 + 3.0f * t02 - 2.1666666666666667f * t03 - 4.333333333333333333f * t04 +
-                          0.66666666666666667f * t05 + 1.333333333333333f * t06;
-    const float16_t m02 = -1.5f * t01 + 3.0f * t02 + 2.1666666666666667f * t03 - 4.333333333333333333f * t04 -
-                          0.66666666666666667f * t05 + 1.333333333333333f * t06;
-    const float16_t m03 = -0.3f * (t01 + t02) + 1.33333333333333f * (t03 + t04) - 0.53333333333f * (t05 + t06);
-    const float16_t m04 = 0.3f * (t01 - t02) + 1.33333333333333f * (t04 - t03) + 0.53333333333f * (t05 - t06);
-    const float16_t m05 = 0.0333333333f * t01 + 0.02222222f * t02 - 0.1666666666f * t03 - 0.1111111111f * t04 +
-                          0.1333333f * t05 + 0.0888888f * t06;
-    const float16_t m06 = -0.0333333333f * t01 + 0.02222222f * t02 + 0.1666666666f * t03 - 0.1111111111f * t04 -
-                          0.1333333f * t05 + 0.0888888f * t06;
-    const float16_t m07 = -0.5625f * t01 + 3.0625f * t03 - 3.5f * t05 + t07;
-
-    float16_t m10 = t10 - 5.444444444444444445125f * t12 + 6.222222222222222222223f * t14 - 1.77777777777777778f * t16;
-    const float16_t m11 = 1.5f * t11 + 3.0f * t12 - 2.1666666666666667f * t13 - 4.333333333333333333f * t14 +
-                          0.66666666666666667f * t15 + 1.333333333333333f * t16;
-    const float16_t m12 = -1.5f * t11 + 3.0f * t12 + 2.1666666666666667f * t13 - 4.333333333333333333f * t14 -
-                          0.66666666666666667f * t15 + 1.333333333333333f * t16;
-    const float16_t m13 = -0.3f * (t11 + t12) + 1.33333333333333f * (t13 + t14) - 0.53333333333f * (t15 + t16);
-    const float16_t m14 = 0.3f * (t11 - t12) + 1.33333333333333f * (t14 - t13) + 0.53333333333f * (t15 - t16);
-    const float16_t m15 = 0.0333333333f * t11 + 0.02222222f * t12 - 0.1666666666f * t13 - 0.1111111111f * t14 +
-                          0.1333333f * t15 + 0.0888888f * t16;
-    const float16_t m16 = -0.0333333333f * t11 + 0.02222222f * t12 + 0.1666666666f * t13 - 0.1111111111f * t14 -
-                          0.1333333f * t15 + 0.0888888f * t16;
-    const float16_t m17 = -0.5625f * t11 + 3.0625f * t13 - 3.5f * t15 + t17;
-
-    const float16_t m20 =
-      t20 - 5.444444444444444445125f * t22 + 6.222222222222222222223f * t24 - 1.77777777777777778f * t26;
-    const float16_t m21 = 1.5f * t21 + 3.0f * t22 - 2.1666666666666667f * t23 - 4.333333333333333333f * t24 +
-                          0.66666666666666667f * t25 + 1.333333333333333f * t26;
-    const float16_t m22 = -1.5f * t21 + 3.0f * t22 + 2.1666666666666667f * t23 - 4.333333333333333333f * t24 -
-                          0.66666666666666667f * t25 + 1.333333333333333f * t26;
-    const float16_t m23 = -0.3f * (t21 + t22) + 1.33333333333333f * (t23 + t24) - 0.53333333333f * (t25 + t26);
-    const float16_t m24 = 0.3f * (t21 - t22) + 1.33333333333333f * (t24 - t23) + 0.53333333333f * (t25 - t26);
-    const float16_t m25 = 0.0333333333f * t21 + 0.02222222f * t22 - 0.1666666666f * t23 - 0.1111111111f * t24 +
-                          0.1333333f * t25 + 0.0888888f * t26;
-    const float16_t m26 = -0.0333333333f * t21 + 0.02222222f * t22 + 0.1666666666f * t23 - 0.1111111111f * t24 -
-                          0.1333333f * t25 + 0.0888888f * t26;
-    const float16_t m27 = -0.5625f * t21 + 3.0625f * t23 - 3.5f * t25 + t27;
-
-    float16_t m30 = t30 - 5.444444444444444445125f * t32 + 6.222222222222222222223f * t34 - 1.77777777777777778f * t36;
-    const float16_t m31 = 1.5f * t31 + 3.0f * t32 - 2.1666666666666667f * t33 - 4.333333333333333333f * t34 +
-                          0.66666666666666667f * t35 + 1.333333333333333f * t36;
-    const float16_t m32 = -1.5f * t31 + 3.0f * t32 + 2.1666666666666667f * t33 - 4.333333333333333333f * t34 -
-                          0.66666666666666667f * t35 + 1.333333333333333f * t36;
-    const float16_t m33 = -0.3f * (t31 + t32) + 1.33333333333333f * (t33 + t34) - 0.53333333333f * (t35 + t36);
-    const float16_t m34 = 0.3f * (t31 - t32) + 1.33333333333333f * (t34 - t33) + 0.53333333333f * (t35 - t36);
-    const float16_t m35 = 0.0333333333f * t31 + 0.02222222f * t32 - 0.1666666666f * t33 - 0.1111111111f * t34 +
-                          0.1333333f * t35 + 0.0888888f * t36;
-    const float16_t m36 = -0.0333333333f * t31 + 0.02222222f * t32 + 0.1666666666f * t33 - 0.1111111111f * t34 -
-                          0.1333333f * t35 + 0.0888888f * t36;
-    const float16_t m37 = -0.5625f * t31 + 3.0625f * t33 - 3.5f * t35 + t37;
-
-    const float16_t m40 =
-      t40 - 5.444444444444444445125f * t42 + 6.222222222222222222223f * t44 - 1.77777777777777778f * t46;
-    const float16_t m41 = 1.5f * t41 + 3.0f * t42 - 2.1666666666666667f * t43 - 4.333333333333333333f * t44 +
-                          0.66666666666666667f * t45 + 1.333333333333333f * t46;
-    const float16_t m42 = -1.5f * t41 + 3.0f * t42 + 2.1666666666666667f * t43 - 4.333333333333333333f * t44 -
-                          0.66666666666666667f * t45 + 1.333333333333333f * t46;
-    const float16_t m43 = -0.3f * (t41 + t42) + 1.33333333333333f * (t43 + t44) - 0.53333333333f * (t45 + t46);
-    const float16_t m44 = 0.3f * (t41 - t42) + 1.33333333333333f * (t44 - t43) + 0.53333333333f * (t45 - t46);
-    const float16_t m45 = 0.0333333333f * t41 + 0.02222222f * t42 - 0.1666666666f * t43 - 0.1111111111f * t44 +
-                          0.1333333f * t45 + 0.0888888f * t46;
-    const float16_t m46 = -0.0333333333f * t41 + 0.02222222f * t42 + 0.1666666666f * t43 - 0.1111111111f * t44 -
-                          0.1333333f * t45 + 0.0888888f * t46;
-    const float16_t m47 = -0.5625f * t41 + 3.0625f * t43 - 3.5f * t45 + t47;
-
-    float16_t m50 = t50 - 5.444444444444444445125f * t52 + 6.222222222222222222223f * t54 - 1.77777777777777778f * t56;
-    const float16_t m51 = 1.5f * t51 + 3.0f * t52 - 2.1666666666666667f * t53 - 4.333333333333333333f * t54 +
-                          0.66666666666666667f * t55 + 1.333333333333333f * t56;
-    const float16_t m52 = -1.5f * t51 + 3.0f * t52 + 2.1666666666666667f * t53 - 4.333333333333333333f * t54 -
-                          0.66666666666666667f * t55 + 1.333333333333333f * t56;
-    const float16_t m53 = -0.3f * (t51 + t52) + 1.33333333333333f * (t53 + t54) - 0.53333333333f * (t55 + t56);
-    const float16_t m54 = 0.3f * (t51 - t52) + 1.33333333333333f * (t54 - t53) + 0.53333333333f * (t55 - t56);
-    const float16_t m55 = 0.0333333333f * t51 + 0.02222222f * t52 - 0.1666666666f * t53 - 0.1111111111f * t54 +
-                          0.1333333f * t55 + 0.0888888f * t56;
-    const float16_t m56 = -0.0333333333f * t51 + 0.02222222f * t52 + 0.1666666666f * t53 - 0.1111111111f * t54 -
-                          0.1333333f * t55 + 0.0888888f * t56;
-    const float16_t m57 = -0.5625f * t51 + 3.0625f * t53 - 3.5f * t55 + t57;
-
-    float16_t m60 = t60 - 5.444444444444444445125f * t62 + 6.222222222222222222223f * t64 - 1.77777777777777778f * t66;
-    const float16_t m61 = 1.5f * t61 + 3.0f * t62 - 2.1666666666666667f * t63 - 4.333333333333333333f * t64 +
-                          0.66666666666666667f * t65 + 1.333333333333333f * t66;
-    const float16_t m62 = -1.5f * t61 + 3.0f * t62 + 2.1666666666666667f * t63 - 4.333333333333333333f * t64 -
-                          0.66666666666666667f * t65 + 1.333333333333333f * t66;
-    const float16_t m63 = -0.3f * (t61 + t62) + 1.33333333333333f * (t63 + t64) - 0.53333333333f * (t65 + t66);
-    const float16_t m64 = 0.3f * (t61 - t62) + 1.33333333333333f * (t64 - t63) + 0.53333333333f * (t65 - t66);
-    const float16_t m65 = 0.0333333333f * t61 + 0.02222222f * t62 - 0.1666666666f * t63 - 0.1111111111f * t64 +
-                          0.1333333f * t65 + 0.0888888f * t66;
-    const float16_t m66 = -0.0333333333f * t61 + 0.02222222f * t62 + 0.1666666666f * t63 - 0.1111111111f * t64 -
-                          0.1333333f * t65 + 0.0888888f * t66;
-    const float16_t m67 = -0.5625f * t61 + 3.0625f * t63 - 3.5f * t65 + t67;
-
-    float16_t m70 = t70 - 5.444444444444444445125f * t72 + 6.222222222222222222223f * t74 - 1.77777777777777778f * t76;
-    const float16_t m71 = 1.5f * t71 + 3.0f * t72 - 2.1666666666666667f * t73 - 4.333333333333333333f * t74 +
-                          0.66666666666666667f * t75 + 1.333333333333333f * t76;
-    const float16_t m72 = -1.5f * t71 + 3.0f * t72 + 2.1666666666666667f * t73 - 4.333333333333333333f * t74 -
-                          0.66666666666666667f * t75 + 1.333333333333333f * t76;
-    const float16_t m73 = -0.3f * (t71 + t72) + 1.33333333333333f * (t73 + t74) - 0.53333333333f * (t75 + t76);
-    const float16_t m74 = 0.3f * (t71 - t72) + 1.33333333333333f * (t74 - t73) + 0.53333333333f * (t75 - t76);
-    const float16_t m75 = 0.0333333333f * t71 + 0.02222222f * t72 - 0.1666666666f * t73 - 0.1111111111f * t74 +
-                          0.1333333f * t75 + 0.0888888f * t76;
-    const float16_t m76 = -0.0333333333f * t71 + 0.02222222f * t72 + 0.1666666666f * t73 - 0.1111111111f * t74 -
-                          0.1333333f * t75 + 0.0888888f * t76;
-    const float16_t m77 = -0.5625f * t71 + 3.0625f * t73 - 3.5f * t75 + t77;
-
-    (dst_data + i)[0] = m00;
-    (dst_data + i + dst_step)[0] = m01;
-    (dst_data + i + 2 * dst_step)[0] = m02;
-    (dst_data + i + 3 * dst_step)[0] = m03;
-    (dst_data + i + 4 * dst_step)[0] = m04;
-    (dst_data + i + 5 * dst_step)[0] = m05;
-    (dst_data + i + 6 * dst_step)[0] = m06;
-    (dst_data + i + 7 * dst_step)[0] = m07;
-
-    (dst_data + i + 8 * dst_step)[0] = m10;
-    (dst_data + i + 9 * dst_step)[0] = m11;
-    (dst_data + i + 10 * dst_step)[0] = m12;
-    (dst_data + i + 11 * dst_step)[0] = m13;
-    (dst_data + i + 12 * dst_step)[0] = m14;
-    (dst_data + i + 13 * dst_step)[0] = m15;
-    (dst_data + i + 14 * dst_step)[0] = m16;
-    (dst_data + i + 15 * dst_step)[0] = m17;
-
-    (dst_data + i + 16 * dst_step)[0] = m20;
-    (dst_data + i + 17 * dst_step)[0] = m21;
-    (dst_data + i + 18 * dst_step)[0] = m22;
-    (dst_data + i + 19 * dst_step)[0] = m23;
-    (dst_data + i + 20 * dst_step)[0] = m24;
-    (dst_data + i + 21 * dst_step)[0] = m25;
-    (dst_data + i + 22 * dst_step)[0] = m26;
-    (dst_data + i + 23 * dst_step)[0] = m27;
-
-    (dst_data + i + 24 * dst_step)[0] = m30;
-    (dst_data + i + 25 * dst_step)[0] = m31;
-    (dst_data + i + 26 * dst_step)[0] = m32;
-    (dst_data + i + 27 * dst_step)[0] = m33;
-    (dst_data + i + 28 * dst_step)[0] = m34;
-    (dst_data + i + 29 * dst_step)[0] = m35;
-    (dst_data + i + 30 * dst_step)[0] = m36;
-    (dst_data + i + 31 * dst_step)[0] = m37;
-
-    (dst_data + i + 32 * dst_step)[0] = m40;
-    (dst_data + i + 33 * dst_step)[0] = m41;
-    (dst_data + i + 34 * dst_step)[0] = m42;
-    (dst_data + i + 35 * dst_step)[0] = m43;
-    (dst_data + i + 36 * dst_step)[0] = m44;
-    (dst_data + i + 37 * dst_step)[0] = m45;
-    (dst_data + i + 38 * dst_step)[0] = m46;
-    (dst_data + i + 39 * dst_step)[0] = m47;
-
-    (dst_data + i + 40 * dst_step)[0] = m50;
-    (dst_data + i + 41 * dst_step)[0] = m51;
-    (dst_data + i + 42 * dst_step)[0] = m52;
-    (dst_data + i + 43 * dst_step)[0] = m53;
-    (dst_data + i + 44 * dst_step)[0] = m54;
-    (dst_data + i + 45 * dst_step)[0] = m55;
-    (dst_data + i + 46 * dst_step)[0] = m56;
-    (dst_data + i + 47 * dst_step)[0] = m57;
-
-    (dst_data + i + 48 * dst_step)[0] = m60;
-    (dst_data + i + 49 * dst_step)[0] = m61;
-    (dst_data + i + 50 * dst_step)[0] = m62;
-    (dst_data + i + 51 * dst_step)[0] = m63;
-    (dst_data + i + 52 * dst_step)[0] = m64;
-    (dst_data + i + 53 * dst_step)[0] = m65;
-    (dst_data + i + 54 * dst_step)[0] = m66;
-    (dst_data + i + 55 * dst_step)[0] = m67;
-
-    (dst_data + i + 56 * dst_step)[0] = m70;
-    (dst_data + i + 57 * dst_step)[0] = m71;
-    (dst_data + i + 58 * dst_step)[0] = m72;
-    (dst_data + i + 59 * dst_step)[0] = m73;
-    (dst_data + i + 60 * dst_step)[0] = m74;
-    (dst_data + i + 61 * dst_step)[0] = m75;
-    (dst_data + i + 62 * dst_step)[0] = m76;
-    (dst_data + i + 63 * dst_step)[0] = m77;
-  }
-#endif
+  vst1_f16(dst_data, vget_low_f16(m00));
+  vst1_f16(dst_data + 64, vget_high_f16(m00));
+  vst1_f16(dst_data + 1 * dst_step, vget_low_f16(m01));
+  vst1_f16(dst_data + 1 * dst_step + 64, vget_high_f16(m01));
+  vst1_f16(dst_data + 2 * dst_step, vget_low_f16(m02));
+  vst1_f16(dst_data + 2 * dst_step + 64, vget_high_f16(m02));
+  vst1_f16(dst_data + 3 * dst_step, vget_low_f16(m03));
+  vst1_f16(dst_data + 3 * dst_step + 64, vget_high_f16(m03));
+  vst1_f16(dst_data + 4 * dst_step, vget_low_f16(m04));
+  vst1_f16(dst_data + 4 * dst_step + 64, vget_high_f16(m04));
+  vst1_f16(dst_data + 5 * dst_step, vget_low_f16(m05));
+  vst1_f16(dst_data + 5 * dst_step + 64, vget_high_f16(m05));
+  vst1_f16(dst_data + 6 * dst_step, vget_low_f16(m06));
+  vst1_f16(dst_data + 6 * dst_step + 64, vget_high_f16(m06));
+  vst1_f16(dst_data + 7 * dst_step, vget_low_f16(m07));
+  vst1_f16(dst_data + 7 * dst_step + 64, vget_high_f16(m07));
+  vst1_f16(dst_data + 8 * dst_step, vget_low_f16(m10));
+  vst1_f16(dst_data + 8 * dst_step + 64, vget_high_f16(m10));
+  vst1_f16(dst_data + 9 * dst_step, vget_low_f16(m11));
+  vst1_f16(dst_data + 9 * dst_step + 64, vget_high_f16(m11));
+  vst1_f16(dst_data + 10 * dst_step, vget_low_f16(m12));
+  vst1_f16(dst_data + 10 * dst_step + 64, vget_high_f16(m12));
+  vst1_f16(dst_data + 11 * dst_step, vget_low_f16(m13));
+  vst1_f16(dst_data + 11 * dst_step + 64, vget_high_f16(m13));
+  vst1_f16(dst_data + 12 * dst_step, vget_low_f16(m14));
+  vst1_f16(dst_data + 12 * dst_step + 64, vget_high_f16(m14));
+  vst1_f16(dst_data + 13 * dst_step, vget_low_f16(m15));
+  vst1_f16(dst_data + 13 * dst_step + 64, vget_high_f16(m15));
+  vst1_f16(dst_data + 14 * dst_step, vget_low_f16(m16));
+  vst1_f16(dst_data + 14 * dst_step + 64, vget_high_f16(m16));
+  vst1_f16(dst_data + 15 * dst_step, vget_low_f16(m17));
+  vst1_f16(dst_data + 15 * dst_step + 64, vget_high_f16(m17));
+  vst1_f16(dst_data + 16 * dst_step, vget_low_f16(m20));
+  vst1_f16(dst_data + 16 * dst_step + 64, vget_high_f16(m20));
+  vst1_f16(dst_data + 17 * dst_step, vget_low_f16(m21));
+  vst1_f16(dst_data + 17 * dst_step + 64, vget_high_f16(m21));
+  vst1_f16(dst_data + 18 * dst_step, vget_low_f16(m22));
+  vst1_f16(dst_data + 18 * dst_step + 64, vget_high_f16(m22));
+  vst1_f16(dst_data + 19 * dst_step, vget_low_f16(m23));
+  vst1_f16(dst_data + 19 * dst_step + 64, vget_high_f16(m23));
+  vst1_f16(dst_data + 20 * dst_step, vget_low_f16(m24));
+  vst1_f16(dst_data + 20 * dst_step + 64, vget_high_f16(m24));
+  vst1_f16(dst_data + 21 * dst_step, vget_low_f16(m25));
+  vst1_f16(dst_data + 21 * dst_step + 64, vget_high_f16(m25));
+  vst1_f16(dst_data + 22 * dst_step, vget_low_f16(m26));
+  vst1_f16(dst_data + 22 * dst_step + 64, vget_high_f16(m26));
+  vst1_f16(dst_data + 23 * dst_step, vget_low_f16(m27));
+  vst1_f16(dst_data + 23 * dst_step + 64, vget_high_f16(m27));
+  vst1_f16(dst_data + 24 * dst_step, vget_low_f16(m30));
+  vst1_f16(dst_data + 24 * dst_step + 64, vget_high_f16(m30));
+  vst1_f16(dst_data + 25 * dst_step, vget_low_f16(m31));
+  vst1_f16(dst_data + 25 * dst_step + 64, vget_high_f16(m31));
+  vst1_f16(dst_data + 26 * dst_step, vget_low_f16(m32));
+  vst1_f16(dst_data + 26 * dst_step + 64, vget_high_f16(m32));
+  vst1_f16(dst_data + 27 * dst_step, vget_low_f16(m33));
+  vst1_f16(dst_data + 27 * dst_step + 64, vget_high_f16(m33));
+  vst1_f16(dst_data + 28 * dst_step, vget_low_f16(m34));
+  vst1_f16(dst_data + 28 * dst_step + 64, vget_high_f16(m34));
+  vst1_f16(dst_data + 29 * dst_step, vget_low_f16(m35));
+  vst1_f16(dst_data + 29 * dst_step + 64, vget_high_f16(m35));
+  vst1_f16(dst_data + 30 * dst_step, vget_low_f16(m36));
+  vst1_f16(dst_data + 30 * dst_step + 64, vget_high_f16(m36));
+  vst1_f16(dst_data + 31 * dst_step, vget_low_f16(m37));
+  vst1_f16(dst_data + 31 * dst_step + 64, vget_high_f16(m37));
+  vst1_f16(dst_data + 32 * dst_step, vget_low_f16(m40));
+  vst1_f16(dst_data + 32 * dst_step + 64, vget_high_f16(m40));
+  vst1_f16(dst_data + 33 * dst_step, vget_low_f16(m41));
+  vst1_f16(dst_data + 33 * dst_step + 64, vget_high_f16(m41));
+  vst1_f16(dst_data + 34 * dst_step, vget_low_f16(m42));
+  vst1_f16(dst_data + 34 * dst_step + 64, vget_high_f16(m42));
+  vst1_f16(dst_data + 35 * dst_step, vget_low_f16(m43));
+  vst1_f16(dst_data + 35 * dst_step + 64, vget_high_f16(m43));
+  vst1_f16(dst_data + 36 * dst_step, vget_low_f16(m44));
+  vst1_f16(dst_data + 36 * dst_step + 64, vget_high_f16(m44));
+  vst1_f16(dst_data + 37 * dst_step, vget_low_f16(m45));
+  vst1_f16(dst_data + 37 * dst_step + 64, vget_high_f16(m45));
+  vst1_f16(dst_data + 38 * dst_step, vget_low_f16(m46));
+  vst1_f16(dst_data + 38 * dst_step + 64, vget_high_f16(m46));
+  vst1_f16(dst_data + 39 * dst_step, vget_low_f16(m47));
+  vst1_f16(dst_data + 39 * dst_step + 64, vget_high_f16(m47));
+  vst1_f16(dst_data + 40 * dst_step, vget_low_f16(m50));
+  vst1_f16(dst_data + 40 * dst_step + 64, vget_high_f16(m50));
+  vst1_f16(dst_data + 41 * dst_step, vget_low_f16(m51));
+  vst1_f16(dst_data + 41 * dst_step + 64, vget_high_f16(m51));
+  vst1_f16(dst_data + 42 * dst_step, vget_low_f16(m52));
+  vst1_f16(dst_data + 42 * dst_step + 64, vget_high_f16(m52));
+  vst1_f16(dst_data + 43 * dst_step, vget_low_f16(m53));
+  vst1_f16(dst_data + 43 * dst_step + 64, vget_high_f16(m53));
+  vst1_f16(dst_data + 44 * dst_step, vget_low_f16(m54));
+  vst1_f16(dst_data + 44 * dst_step + 64, vget_high_f16(m54));
+  vst1_f16(dst_data + 45 * dst_step, vget_low_f16(m55));
+  vst1_f16(dst_data + 45 * dst_step + 64, vget_high_f16(m55));
+  vst1_f16(dst_data + 46 * dst_step, vget_low_f16(m56));
+  vst1_f16(dst_data + 46 * dst_step + 64, vget_high_f16(m56));
+  vst1_f16(dst_data + 47 * dst_step, vget_low_f16(m57));
+  vst1_f16(dst_data + 47 * dst_step + 64, vget_high_f16(m57));
+  vst1_f16(dst_data + 48 * dst_step, vget_low_f16(m60));
+  vst1_f16(dst_data + 48 * dst_step + 64, vget_high_f16(m60));
+  vst1_f16(dst_data + 49 * dst_step, vget_low_f16(m61));
+  vst1_f16(dst_data + 49 * dst_step + 64, vget_high_f16(m61));
+  vst1_f16(dst_data + 50 * dst_step, vget_low_f16(m62));
+  vst1_f16(dst_data + 50 * dst_step + 64, vget_high_f16(m62));
+  vst1_f16(dst_data + 51 * dst_step, vget_low_f16(m63));
+  vst1_f16(dst_data + 51 * dst_step + 64, vget_high_f16(m63));
+  vst1_f16(dst_data + 52 * dst_step, vget_low_f16(m64));
+  vst1_f16(dst_data + 52 * dst_step + 64, vget_high_f16(m64));
+  vst1_f16(dst_data + 53 * dst_step, vget_low_f16(m65));
+  vst1_f16(dst_data + 53 * dst_step + 64, vget_high_f16(m65));
+  vst1_f16(dst_data + 54 * dst_step, vget_low_f16(m66));
+  vst1_f16(dst_data + 54 * dst_step + 64, vget_high_f16(m66));
+  vst1_f16(dst_data + 55 * dst_step, vget_low_f16(m67));
+  vst1_f16(dst_data + 55 * dst_step + 64, vget_high_f16(m67));
+  vst1_f16(dst_data + 56 * dst_step, vget_low_f16(m70));
+  vst1_f16(dst_data + 56 * dst_step + 64, vget_high_f16(m70));
+  vst1_f16(dst_data + 57 * dst_step, vget_low_f16(m71));
+  vst1_f16(dst_data + 57 * dst_step + 64, vget_high_f16(m71));
+  vst1_f16(dst_data + 58 * dst_step, vget_low_f16(m72));
+  vst1_f16(dst_data + 58 * dst_step + 64, vget_high_f16(m72));
+  vst1_f16(dst_data + 59 * dst_step, vget_low_f16(m73));
+  vst1_f16(dst_data + 59 * dst_step + 64, vget_high_f16(m73));
+  vst1_f16(dst_data + 60 * dst_step, vget_low_f16(m74));
+  vst1_f16(dst_data + 60 * dst_step + 64, vget_high_f16(m74));
+  vst1_f16(dst_data + 61 * dst_step, vget_low_f16(m75));
+  vst1_f16(dst_data + 61 * dst_step + 64, vget_high_f16(m75));
+  vst1_f16(dst_data + 62 * dst_step, vget_low_f16(m76));
+  vst1_f16(dst_data + 62 * dst_step + 64, vget_high_f16(m76));
+  vst1_f16(dst_data + 63 * dst_step, vget_low_f16(m77));
+  vst1_f16(dst_data + 63 * dst_step + 64, vget_high_f16(m77));
 }
 
 void OutputTransform4x2UnitFp16(const float16_t *src_data, float16_t *dst_data, const float16_t *bias_data,